Question

Since vector elements are stored contiguously, I guess it may not have the same address after some push_back’s , because the initial allocated space could not suffice.

I’m working on a code where I need a reference to an element in a vector, like:

int main(){
    vector<int> v;
    v.push_back(1);
    int *ptr = &v[0];
    for(int i=2; i<100; i++)
        v.push_back(i);
    cout << *ptr << endl; //?
    return 0;
}

But it’s not necessarily true that ptr contains a reference to v[0], right? How would be a good way to guarantee it?

My first idea would be to use a vector of pointers and dynamic allocation. I’m wondering if there’s an easier way to do that?

PS.: Actually I’m using a vector of a class instead of int, but I think the issues are the same.

Answer 1

Don’t use reserve to postpone this dangling pointer bug – as someone who got this same problem, shrugged, reserved 1000, then a few months later spent ages trying to figure out some weird memory bug (the vector capacity exceeded 1000), I can tell you this is not a robust solution.

You want to avoid taking the address of elements in a vector if at all possible precisely because of the unpredictable nature of reallocations. If you have to, use iterators instead of raw addresses, since checked STL implementations will tell you when they have become invalid, instead of randomly crashing.

The best solution is to change your container:

• You could use std::list – it does not invalidate existing iterators when adding elements, and only the iterator to an erased element is invalidated when erasing
• If you’re using C++0x, std::vector<std::unique_ptr<T>> is an interesting solution
• Alternatively, using pointers and new/delete isn’t too bad – just don’t forget to delete pointers before erasing them. It’s not hard to get right this way, but you have to be pretty careful to not cause a memory leak by forgetting a delete. (Mark Ransom also points out: this is not exception safe, the entire vector contents is leaked if an exception causes the vector to be destroyed.)
• Note that boost’s ptr_vector cannot be used safely with some of the STL algorithms, which may be a problem for you.