When pushing a new object, a pointer to that object becomes garbage - c++

Question

When I am pushing a reference to an object from a vector in a map the previous value in the reference vector becomes garbage, but the original object doesn't.
Here is the minimal code that reproduces the problem:
#include <iostream>
#include <vector>
#include <map>
#include <string>
class foo
{
private:
std::map<std::string, std::vector<int>> _allObjs;
std::vector<int*> _someObjs;
public:
void addObj(const std::string &name, int obj)
{
_allObjs[name].push_back(obj);
_someObjs.push_back(&_allObjs[name].back());
}
void doStuff()
{
for (auto &obj : _someObjs)
{
std::cout << *obj << std::endl;
}
}
};
int main()
{
foo test;
test.addObj("test1", 5);
test.addObj("test1", 6);
test.addObj("test2", 7);
test.addObj("test2", 8);
test.doStuff();
}
Expected Output
5
6
7
8
Actual Output
-572662307
6
-572662307
8
When debugging it I found the pointer becomes garbage as soon as I push the object to _allObjs in addObj. I have no idea what is causing this, so I can't be much help there. Thanks!

Answer 1

A vector stores its data in a contiguous block of memory.
When you want to store more than it currently has capacity for, it will allocate a new, larger contiguous block of memory, and copy/move all the existing elements from the previous block of memory into the new one.
When you store pointers to your ints (&_allObjs[name].back()), you're storing the memory address of the int in one of these blocks of memory.
As soon as the vector grows to a size where it needs to create additional space, all these memory addresses will be pointing to deallocated addresses. Accessing them is undefined behaviour.

Answer 2

Let us see what this reference page says about inserting new objects to a vector:
If the new size() is greater than capacity() then all iterators and references (including the past-the-end iterator) are invalidated. Otherwise only the past-the-end iterator is invalidated.
So, when you add a new object, the previously stored pointers that refer to objects in that same vector may become invalid i.e. they no longer point to valid objects (unless you have made sure that capacity is not exceeded, which you didn't).

Answer 3

The pointers in your
std::vector<int*> _someObjs;
aren't stable.
When you use
_allObjs[name].push_back(obj);
any addresses obtained earlier might be invalidated due to reallocation.
As written in the reference:
If the new size() is greater than capacity() then all iterators and references (including the past-the-end iterator) are invalidated. Otherwise only the past-the-end iterator is invalidated.

Answer 4

As others have rightfully mentioned, adding items to a vector may be invalidating iterators and references on resizing of the vector.
If you want to quickly alleviate the situation with minimal code changes, change from a
std::map<std::string, std::vector<int>>
to
std::map<std::string, std::forward_list<int>>
or
std::map<std::string, std::list<int>>
Since a std::list / std::forward_list does not invalidate iterators and references when resizing the list, then the above scenario should work (the only iterators that will be invalidated are ones pointing to items that you've removed from the list).
Example using std::list
Note that the drawback is that usage of linked list will not store items in contiguous memory unlike std::vector, and std::list takes up more memory.

Answer 5

This: _allObjs[name].push_back(obj); (and the other push_back) potentially invalidates all iterators (and pointers) into the vector. You cannot assume anything about them afterwards.