Does passing containers by value invalidate iterators?

Question

Here is some example code:

#include <iostream>
#include <vector>

template <typename T>
std::vector<typename T::iterator> f(T t)
{
        std::vector<typename T::iterator> v;
        for (auto i = t.begin(); i != t.end(); ++i)
        {
                v.push_back(i);
        }
        return v;
}

template <typename T>
void print(const std::vector<T>& v)
{
        for (auto i = v.begin(); i != v.end(); ++i)
        {
                std::cout << **i << ' ';
        }
        std::cout << std::endl;
}

int main()
{
        std::vector<int> v{1, 2, 3};
        print(f(v));
        std::vector<std::vector<int>::iterator> itervec = f(v);
        print(itervec);
}

On ideone the output was:

1 2 3 
163487776 2 3 

Questions

If I change f(T t) to f(T& t) the output is as expected. I'm assuming because I am working with copies of containers, technically the iterators I am pushing back on the vector are not the same as the vector I created in main. Is this correct? The one thing I noticed is print(f(v)); prints 1 2 3 as expected but as soon as I assign it to itervec the first iterator becomes garbage, is this all implementation dependent?

Peritonitis

Answer 1

Yes, the iterators are iterators only valid for the local object v in the function f, and at the end of f, v goes out of scope and is destroyed, and the iterators are invalid.

You have to pass the vector by reference (or pointer or whatever) so that the iterators you store are the iterators for the original object that the caller passes in, not for a temporary copy stored in a local variable.

The behaviour you are seeing is undefined, so it just happens to print the first three and last two correctly.

Lockett

Answer 2

Yes, because you are recieving a temporary and returning an iterator of that temporary. After function exit the temporary gets cleaned up, invalidating the iterator.

If you however get passed a reference both main and print are accessing the same object. Since this object persists after function exit the iterator is not invalidated.

Tyrolienne