Question

A const int * and an int *const are very different. Similarly with const std::auto_ptr<int> vs. std::auto_ptr<const int>. However, there appears to be no such distinction with const std::vector<int> vs. std::vector<const int> (actually I’m not sure the second is even allowed). Why is this?

Sometimes I have a function which I want to pass a reference to a vector. The function shouldn’t modify the vector itself (eg. no push_back()), but it wants to modify each of the contained values (say, increment them). Similarly, I might want a function to only change the vector structure but not modify any of its existing contents (though this would be odd). This kind of thing is possible with std::auto_ptr (for example), but because std::vector::front() (for example) is defined as

const T &front() const;
T &front();

rather than just

T &front() const;

There’s no way to express this.

Examples of what I want to do:

//create a (non-modifiable) auto_ptr containing a (modifiable) int
const std::auto_ptr<int> a(new int(3));

//this works and makes sense - changing the value pointed to, not the pointer itself
*a = 4;
//this is an error, as it should be
a.reset();


//create a (non-modifiable) vector containing a (modifiable) int
const std::vector<int> v(1, 3);

//this makes sense to me but doesn't work - trying to change the value in the vector, not the vector itself
v.front() = 4;
//this is an error, as it should be
v.clear();

Answer 1

It’s a design decision.

If you have a const container, it usually stands to reason that you don’t want anybody to modify the elements that it contains, which are an intrinsic part of it. That the container completely “owns” these elements “solidifies the bond”, if you will.

This is in contrast to the historic, more lower-level “container” implementations (i.e. raw arrays) which are more hands-off. As you quite rightly say, there is a big difference between int const* and int * const. But standard containers simply choose to pass the constness on.