Why doesn\'t C support template covariance, and how can we address the resulting type safety issues when working with polymorphic templates?

Templates and Polymorphism in C

Consider the following class structure:

<code class="cpp">class Interface {
  // ...
};

class Foo : public Interface {
  // ...
};

template &lt;class T&gt;
class Container {
  // ...
};</code>

A constructor of some other class Bar is defined as:

<code class="cpp">Bar(const Container&lt;Interface&gt;&amp; bar) {
  // ...
}</code>

However, when attempting to call the constructor as follows:

<code class="cpp">Container&lt;Foo&gt; container();

Bar *temp = new Bar(container);</code>

we encounter a "no matching function" error.

Polymorphism in Templates

The concept of polymorphism in templates, or template covariance, would imply that if class B inherits from class A, then T<B> likewise inherits from T<A>. However, this is not the case in C or other languages like Java or C#.

Reason for Lack of Template Covariance

The absence of template covariance is justified by the need to maintain type safety. Consider the following example:

<code class="cpp">// Class hierarchy
class Fruit {...};
class Apple : public Fruit {...};
class Orange : public Fruit {...};

// Template instantiation using std::vector
int main() {
  std::vector&lt;Apple&gt; apple_vec;
  apple_vec.push_back(Apple()); // Valid

  // With covariance, the following would be allowed
  std::vector&lt;Fruit&gt;&amp; fruit_vec = apple_vec;

  // Adding an Orange to the vector
  fruit_vec.push_back(Orange());

  // Incorrect addition of an orange to an apple vector
}</code>

This demonstrates the potential for unsafe behavior if templates were covariant. Therefore, T<A> and T<B> are considered completely distinct types, regardless of the relationship between A and B.

Resolving the Issue

One approach to resolving the issue in Java and C# is to use bounded wildcards and constraints, respectively:

<code class="java">Bar(Container&lt;? extends Interface) {...}

<code class="csharp">Bar&lt;T&gt;(Container&lt;T&gt; container) where T : Interface {...}</code>

In C , the Boost Concept Check library can provide similar functionality. However, using a simple static assert may be a more practical solution for the specific problem encountered:

<code class="cpp">static_assert(std::is_base_of&lt;Interface, Foo&gt;::value, "Container must hold objects of type Interface or its derived classes.");</code>

The above is the detailed content of Why doesn\'t C support template covariance, and how can we address the resulting type safety issues when working with polymorphic templates?. For more information, please follow other related articles on the PHP Chinese website!