If a vector contains a bunch of elements that were allocated using new and then dereferenced, is the memory for those elements freed when the vector is deleted? For example:
vector<Obj> a = *(new vector<Obj>());
a.push_back(*(new Obj()));
delete &a;
Is the new Obj that was created deallocated?
This is all going to go horribly wrong. Firstly, the assignment on the first line, "a" is on the stack now (not the heap), and the memory allocated by your new statement is now lost, leaked, gone.
Secondly, re-occurrance of the same situation. Obj() will be constructed, and copied. The memory from your 2nd new lost in the depths of space and time, forever.
Then you try and delete an object allocated on the stack. This is where your program crashes and burns and all that memory loss is inconsequential.
vector<Obj> a;
Obj o;
a.push_back(o);
Note: no new or delete in sight. C++ isn't Java.
No; you seem to be having some trouble with ownership in general. In this declaration:
vector<Obj> a = *(new vector<Obj>());
You are allocating a new vector, copying it, then throwing away the original. Since you no longer have a pointer to it, you cannot delete it. This is called a memory leak. Further, this:
delete &a;
Is undefined behaviour, because you’re not deleting an object allocated via new, but rather a local. What you perhaps meant was this:
vector<Obj*> a;
// ...
That is, allocate a local vector<Obj> named a, whose storage is automatically reclaimed when it goes out of scope.
Now for your actual question, no, the vector only owns the pointers, not the memory to which they point. Consider what would happen otherwise:
vector<Obj*> a;
Obj x;
a.push_back(&x);
If the vector called delete on all its pointer elements, then when a were destroyed (again, automatically), x would also be deleted. Since it was not allocated via new, this is undefined behaviour. Luckily, this is not the case!
If you want a vector of pointers which automatically destroy their referents when the vector is destroyed, use a vector of unique_ptr:
vector<unique_ptr<Obj>> a;
a.push_back(unique_ptr(new Obj()));
No. The *(new Obj()) statement pushes (into the vector) a copy of the heap-allocated object. The copied object (in the vector) is later destroyed (when the vector is destroyed), but the original heap-allocated Obj object is never deleted (and the the heap-allocated memory is never freed).
The vector<Obj> a part allocates an empty vector on the stack.
= *(new vector<Obj>()); Allocates another empty vector on the heap and assigns (copies) it to the stack vector. The memory allocated on the heap has no reference and is leaked.
a.push_back(*(new Obj())); Allocates an Obj on the heap and copies it into the stack vector. The memory allocated on the heap is leaked.
delete &a; Tries to delete the vector allocated on the stack which is an error.
Maybe this is what you're trying to do:
vector<Obj*>* a = new vector<Obj*>();
a.push_back(new Obj());
delete a;
And no, the objects pushed back into the vector will not be deallocated, they will be leaked. When calling delete on the vector pointer a it will default deconstruct the vector which does not involve deallocating dynamically allocated memory.
Tip: Don't use naked pointers, prefer to use unique_ptr or shared_ptr.
