Why doesn't C++ support covariance in STL containers like C# or Java?

Question

The Covariance and Contravariance feature is well supported in C# and Java collections. However C++ doesn't support them in their STL containers. Why is it so?

For example the below code will compile in C# and Java but not in C++. (The syntax will have to be translated to the specific language though)

class Base
{

};

class Child : public Base
{

};

int main()
{
    std::vector<Base*> baseArray;
    std::vector<Child*> ChildArray;

    baseArray = ChildArray;

    return 0;
}

Answer 1

The reason is the underlying object and memory models.

To simplify the reasoning:

• In java and C#, objects of a class are managed by reference. Containers do not store directly the object value but a reference that says where to find the value. It is therefore technically easy to mix objects of different types in the same container (polymorphism) or to use the container for objects of covariant types. The only constraint is the language semantics. This facilitates significantly the implementation of covariant containers.

• In C++, objects are managed by value, following the rules of its memory model, which basically requires that objects of a given type a stored within a fixed size (which of course can contain pointers to elements having a dynamic size). A container therefore has to know the type of its objects at compile-time. Unfortunately (or not) C++ also allows for separate compilation. So when you compile a container for Animals in one translation unit, the compiler might not know the size of a Cat (which might not even yet be developed). All this makes it extremely difficult to implement covariance in the language.

Interestingly, in C# you can have objects that are managed by value (in the case of a struct). But as this Microsoft documentation and this SO question explain, variance only applies to reference types.

Of course, all this is simplified explanations and language-lawyers could argue on some details, but i hope it helps to grasp the idea.

Answer 2

C++ templates are invariant. In other words, they don't support covariance or contravariance.

So, the reason, STL containers are not covariant, is because C++ doesn't support that.

Note that std::vector is mutable, so it cannot be covariant anyway, it needs to be invariant, otherwise it wouldn't be type-safe.

Answer 3

In Java, generics are invariant; you would need to use bounded wildcards to achieve covariance or contravariance. To do what you want, in Java it would need to be declared like this:

List<? extends Base> baseArray;
List<Child> childArray;
baseArray = ChildArray;

By using the ? extends wildcard, Java prevents you from adding any elements other than null into the list using the reference of type List<? extends Base>, since the wildcard stands for an unknown type and you don't know that what you're adding is an instance of that type. You can only get elements out of it.

(It is true that arrays in Java are covariant, but it seems like you are talking about generic containers here, not arrays.)

C++ doesn't have bounded wildcards. The most common use case of bounded wildcards in Java is when you accept a collection parameter that the method only needs to read out of, so it doesn't really care about the exact type argument, only that the type argument is a particular type or its subtype:

void printListOfBase(List<? extends Base> list) {
    // you can call methods of Base on the elements of list
}

In C++, you can achieve the same thing with templates without needing any bound, because C++ template instantiations are "duck-typed". Unlike in Java, where a generic class or method is only compiled once and you must prove to the compiler when compiling the class/methd that what you are doing is type-safe giving the bounds, in C++, a templated class or function is compiled separately for each instantiation (i.e. each type argument used), and so the compiler can check when compiling a specific instantiation whether the type works or not, without needing bounds specified beforehand:

void printListOfBase<T>(std::vector<T> list) {
    // you can call methods of Base on the elements of list
    // and it will compile as long as T has such a method
}

As for your particular case of having a local variable of a wildcard-parameterized type, that is much less common and there is no direct equivalent for it in C++.

Answer 4

In C# and Java, when you do x = y;¹, you now have (at least) two names for the same Object. In C++ you still have two distinct objects, but some code ran and they presumably have the same value now.

The semantics of baseArray = ChildArray in C++ would be very different if it were allowed, it would be a copy operation.

You can copy the contents of ChildArray into baseArray, but not with =

baseArray.assign(ChildArray.begin(), ChildArray.end());

The boost library has a helper for situations like this

#include <boost/range/iterator_range.hpp>

baseArray = boost::copy_range<decltype(baseArray)>(ChildArray);

Footnote 1: Assuming x and y aren't primitives. In that case it matches the C++ case.