1

I'm parsing a file and creating a vector of a vector of Foo objects.

vector< vector<Foo*> > mFooVectors;

I have to allow access with the following getFoos function. 

const vector<const Foo*>&         getFoos(int index);

So I created a const declaration of my vector:

const vector< const vector<const Foo*> > mConstFooVectors;

Now how do I do mConstFooVectors = mFooVectors so I can return a reference to mConstFooVectors?

  • If you can, change the interface of `getFoos`. The problem is that a `const vector` cannot provide an immutable view of a `vector` in the same way that a `T const *const *` can provide an immutable view of something originally pointed to by a `T**`. The standard guarantees that `T*` and `const T*` have the same object representation, thus allowing the pointer conversion, but `vector` doesn't "know" that and doesn't allow the corresponding conversion. – Steve Jessop Jul 18 '11 at 17:50
  • So, if what you want is to provide a view of `mFooVectors` that forbids modification (to the vectors or to whatever's on the end of those pointers), you really need to return iterators. You could for example write your own iterator class to wrap the vector iterators, or you could write a Visitor-pattern-style function to do the iteration on behalf of the caller. – Steve Jessop Jul 18 '11 at 17:59
  • @Paul - just guessing that the downvoter, seeing `vector`, found the rest of the question uninteresting. It just doesn't work. – Bo Persson Jul 18 '11 at 18:22
  • It appears I need to return iterators or just forget about preventing the user from modifying the objects in the vector. The getFoos format was sent down from on high by someone who was guessing about how we should set the interface for this class. –  Jul 18 '11 at 18:48

4 Answers4

8

You cannot add const at any given level that easy. Different instantiations of a template are different unrelated types, a vector<T> is unrelated to a vector<const T>, and there is no way of casting from one to the other.

You can, on the other hand, create a different vector and just copy the contents, but that might be expensive, as you would have to copy all the different contained vectors.

By the way, if you return a const reference to the outer vector, the const reference will behave as: const std::vector< const std::vector< Foo * const > >&, note that because of the value semantics associated to types in C++, const-ness propagates in. The problem is that the value stored in the inner vector is a pointer, and making that pointer constant does not make the pointed-to object constant. Similarly, the behavior of your getFoos(int) will be equivalent to const std::vector< Foo * const >&. Note, that is behavior not actual types.

David Rodríguez - dribeas
  • 204,818
  • 23
  • 294
  • 489
  • 2
    Using a `vector` will fail anyway, as the value_type has to be assignable. – Bo Persson Jul 18 '11 at 18:19
  • @Bo: Right, good point. I did not even think on the details of what template we were talking about here. But it is a really good point: STL containers have specific requirements on the types, and a constant type will not cut it. +1 – David Rodríguez - dribeas Jul 18 '11 at 18:25
  • @BoPersson that was true in C++03. In C++11 it doesn't, however [see here](http://stackoverflow.com/questions/6954906/does-c0x-allow-vectorconst-t). – M.M Mar 01 '15 at 06:39
  • @MattMcNabb: Even in C++11 the type must be assignable, `std::vector` is not a valid specialization (with any sane implementation of `T` for which `operator=` is not a const-member function. – David Rodríguez - dribeas Mar 02 '15 at 21:24
1

I don't know what you are trying to do, but I'd have a look at boost::ptr_vector

Specially, your vector member can potentially leak if you don't handle it correctly... (RAII)

piotr
  • 5,657
  • 1
  • 35
  • 60
0

vector's copy constructor should be able to handle it, but you'll have to do it in the initializer list of your class's constructor since it's a const member.

Edit: That was wrong... Vector's copy constructor can't handle it. See David Rodriguez' post for an explanation (vector and vector are unrelated types).

Nathan Monteleone
  • 5,430
  • 29
  • 43
0

You are mixing a 

vector<const Foo *>

with 

vector<Foo *>

You have to decide which one you want - there is no way to convert from one to another (without making a copy).

kaalus
  • 4,475
  • 3
  • 29
  • 39