STL container assignment and const pointers.

Question

This compiles:

int* p1;
const int* p2;
p2 = p1;

This does not:

vector<int*> v1;
vector<const int*> v2;
v2 = v1;  // Error!
v2 = static_cast<vector<const int*> >(v1);  // Error!

What are the type equivalence rules for nested const pointers? I thought the conversion would be implicit. Besides, I'd rather not implement point-wise assignment of STL containers, unless I really have to.

Answer 1

The issue is not the pointers, but the types of the two vectors. There are no standard conversions between templated types like those of v1 and v2 in your example.

This is perhaps easier to see in the following code:

#include <vector>
using namespace std;

int main() {
    vector <char> cv;
    vector <int> iv;
    cv = iv; // error
}

Answer 2

Conversion from int* to const int* is built into the language, but vectors of these have no automatic conversion from one to the other.

Answer 3

Direct assignment is not possible. As others explained, the equivalence is not established by the pointer types, but by the container types. In this case, vector doesn't want to accept another vector that has a different, but compatible element type.

No real problem, since you can use the assign member function:

v2.assign(v1.begin(), v1.end());

Answer 4

It would be perfectly possible to write your own version of vector where this was possible. It would be identical to the standard type, but with a templated version of operator=, something like this:

template <class A>
vector2<T> &operator=(const vector2<A> &other)
{
    assign(other.begin(), other.end());
    return *this;
}

Where T is the element type of the whole class, whereas A is any type assignable to T.

It's not clear to me why std::vector doesn't have this.

Answer 5

In C++ templated classes, each instantiation of the template is a completely different class - there is as much difference between vector<int *> and vector<const int *> as there is between vector<int *> and vector<string> or any other two classes for that matter.

It is possible that the committee could have added a conversion operator on vector to vector<U> as Earwicker suggests - and you can go ahead and provide your own implementation of such a function:

template <class A, class T>
vector<T> convert_vector(const vector<A> &other)
{
    vector<T> newVector;
    newVector.assign(other.begin(), other.end());
    return newVector;
}

and use it like so:

vector<int*> v1;
vector<const int*> v2;
v2 = convert_vector<const int*>(v1);

Unfortunately, until C++0x comes with it's move constructors, this will be pretty bad performance-wise.

Answer 6

Coercion by Member Template idiom is one possible approach to solve the problem. Essentially, a member template copy-assignment operator is added that allows the template class to participate in the same implicit type conversions (coercion) that are otherwise possible only on the type parameters of the class template. Although the idiom is used in the STL in other places, it is not available in std::vector.

Answer 7

Dangerous, unless you know the types are absolutely compatible:

v2 = reinterpret_cast<std::vector<const int *> & >(v1);

Most STL implementations do use a specialization were all vectors of pointers share the same underlying implementation. This is since (void *) is typically the same size as (int *) or any other pointer type.