Does push_back in vector insert at the same location? - c++

Question

class Example
{
public: int i;
Example(const Example &e)
{
i = e.i;
}
Example(int i)
{
this->i = i;
}
};
int main()
{
std::vector<Example*> vec;
std::vector<Example*> newVec;
Example* ex1 = new Example(1);
Example* ex2 = new Example(2);
vec.push_back(ex1);
vec.push_back(ex2);
//newVec = vec; --> This does shallow copy
for(int i=0; i<vec.size(); ++i) // --> Deep copy
{
Example newE(*(vec[i]));
newVec.push_back(&newE);
}
for(int i=0; i<newVec.size(); ++i)
{
std::cout << "\nfoobar" << newVec[i]->i << "\n";
}
}
The above code prints foobar2 twice. Shouldn't it print foobar1 and foobar2? Also, is this the best way to copy a vector containing objects? I want deep copying.

Answer 1

for(int i=0; i<vec.size(); ++i) // --> Deep copy
{
Example newE(*(vec[i]));
newVec.push_back(&newE);
}
In this code you make a copy of vec[i] to Example newE. Then you push_back the address of newE to the newVec vector. Then the newE object goes out of scope and is destroyed, so you end up having a pointer to garbage inside newVec.
If you want a deep copy of vector content, and you want to store owning pointers to objects, consider using vector of smart pointers, e.g. vector<shared_ptr<Example>>.
In this case, you can simply copy the vectors with operator=, and the reference counts of the shared_ptrs will be automatically updated.
Yoy may want to consider also the simpler design of just having vector<Example> (without pointer indirection).

Answer 2

Your code is not correct and results in undefined behavior.
This loop is problematic:
for(int i=0; i<vec.size(); ++i) // --> Deep copy
{
Example newE(*(vec[i]));
newVec.push_back(&newE);
}
You declare a local variable newE. Such variable has automatic storage duration (often referred as stack allocated, although the C++ standard technically does not require a stack to be used to implement them).
Variables with automatic storage duration have the following properties:
Their lifetime start at the point they are declared.
Their lifetime end at the end of the scope they are declared in.
Each iteration of your for loop is a scope, so after the first iteration, newE is not valid anymore and the compiler is free to generate instructions that will reuse the memory.
This is exactly what happen in your case (and in any decent implementation): each iteration will place newE at the exact same address.
But, as you used operator& to take the address of newE, and newE then goes out of scope, you now have a dangling pointer.
Dangling pointers by themselves are not problematic, but you can't do anything really meaningful with them. In particular, dereferencing one results in undefined behavior.
You have multiple ways to fix your code.
The easy way would be using new:
Example* newE = new Example(*vec[i]);
newVec.push_back(newE);
But you would then have to make sure to add the appropriates delete too. Also, this is not really pedantic C++.
Another way would be to change vec and newVec to std::vector<Example>, to sidestep the raw pointers issues. This would be the preferred way to express your code in C++.
In some cases you need the pointers, if you do polymorphism for example. Then, you may use std::unique_ptr or std::shared_ptr to have pointer semantics and RAII.

Answer 3

Example newE(*(vec[i]));
newVec.push_back(&newE);
allocates newE on the stack, then pushes a pointer to it into the vector. newE goes out of scope at the end of the loop iteration, and you just go lucky that the location of newE is not reused. It seems the compiler generated code that puts both stack-instances in the same place, so you overwrite that location with the second value, then you de-reference that location twice, when iterating over the vector of pointers.