CODEWITHSUNDEEP
c++iteratorcontainers
Jesse Good
Jesse Good

Reputation: 52365

Does passing containers by value invalidate iterators?

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?

Upvotes: 7

Views: 377

Answers (2)

Seth Carnegie
Seth Carnegie

Reputation: 75130

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.

Upvotes: 8

orlp
orlp

Reputation: 117661

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.

Upvotes: 3

Related Questions