Templates Polymorphism: Understanding Covariance

When dealing with templates, it's important to address the topic of polymorphism. The inquiry involves a class structure and a constructor that employs a template. However, when attempting to call the constructor using a template class instance, an error occurs. This raises the question: Are templates not polymorphic?

Template Invariance

Contrary to the nature of inheritance in object-oriented programming, templates do not exhibit polymorphism. This means that if class B inherits from class A, there is no inherent relationship between template class T and T. This is known as template invariance.

Reason for Non-Covariance

Template invariance exists to preserve type safety. If templates were covariant, a type parameter in a parent class could be replaced by a type parameter in a child class. This would lead to potential type mismatch issues, as demonstrated in the following example:

struct Fruit {};
struct Apple : public Fruit {};
struct Orange : public Fruit {};

// Instantiate a vector using a specific type parameter
vector apple_vec;

// If templates were covariant, the following would be legal
vector &fruit_vec = apple_vec;

// Push an element of a different type
fruit_vec.push_back(Orange()); // Invalid operation!

In this example, adding an orange to a vector intended for apples violates type safety.

Addressing the Problem

To resolve the original issue, the constructor can employ a static assertion to verify that the template parameter is the same type as the expected interface. Another solution involves using language features like bounded wildcards or constraints from Java or C#, respectively.

Conclusion

Templates in C do not exhibit polymorphism, ensuring type safety. When working with templates, it's crucial to be aware of this limitation and employ techniques such as static assertions or language-specific features to handle inheritance scenarios effectively.