Vector of objects in stack memory

Question

I want to make a vector of objects, but I don't want to allocate them on the heap. I want to allocate them onto stack memory. But I'm running into issues.

struct Object { int x; Object(int x) { this->x = x; } };

int main() {
    std::vector<Object*> v;

    for (int i = 0; i < 5; i++) {
        Object o (i);
        v.push_back(&o);
        std::cout << &o << std::endl; // keeps printing the same mem address...
                                      // ...implying that these are all the same object
    }
}

I have a suspicion that the object is deleting itself after going out of scope after each iteration of the for-loop.

Now, I know that you can just do v.push_back(new Object(i)) for each iteration and it would work. However, I do not want these objects allocated onto the heap where I need to manually manage the memory.

Answer 1

You are basically correct that "object is [being destructed] after going out of scope". It's also confusing because of what you're printing. Based on how the compiler allocates the variables with "automatic storage duration" within the loop, the stack variable Object o always has the same address.

std::vector<Object*> v;
for (int i = 0; i < 5; i++) {
    Object o (i);
    v.push_back(&o);
    // Variable o still exists on the stack
    std::cout << &o << std::endl; // Prints the address of the automatic variable 'o'
}

// At this point, no objects exist; they all went out of scope
// every pointer in v is invalid, pointing to the "ghost" of a destoryed object.

I think the simpler approach you are looking for is to simply create a vector of objects.

std::vector<Object> v;

for (int i = 0; i < 5; i++) {
    v.push_back(Object(i));
    std::cout << &(v.back()) << std::endl; // Prints the address of the Object just added
}

That said, you should understand that the std::vector<Object> will manage your object lifetimes properly, destroying the objects when the vector itself goes out of scope. But the objects are actually stored on the free store. This is okay.

Here is the output from ideone when compiling and running with a vector of Objects:

0x8e66008
0x8e6601c
0x8e66030
0x8e66034
0x8e66050

Answer 2

If you really don't want to allocate them on the stack, but instead just want the memory managed, you really should take few hours to fill in some knowledge gaps.

In particular, picking up a good amount of knowledge on RAII is crucial to using C++ and C++11 effectively. I highly recommend The C++ Language Reference, 4th Edition. The 4th edition is important because it's very different from the the 3rd edition.

In it, it'll show you that will likely want to use std::vector<std::unique_ptr> for this particular problem, or to make Object a managed object itself (with move semantics implemented).

Answer 3

The vector is deleted, not the objects.

The following means that you save pointers in the vector v:

std::vector<Object*> v;

You could do this:

std::vector<Object> v;

in which case you get many objects, but then you get copies of your objects which at times is either not possible or not something you want (although newer version of the C++ compiler can do a move instead of a copy, but I don't think that would work in this case...)

Another way if you want the Objects to be allocated and then automatically deleted is to use a smart pointer.

#include <memory>
std::vector<std::shared_ptr<Object> > v;

In that case the Objects are allocated by you and freed whenever the vector gets deleted.

However, your problem is that you initialize objects on the stack and assign that stack pointer to your vector. I would image that your print shows you that the pointer is always the same... meaning that the previous object gets destroyed and a new one created on each iteration.

So I would replace these lines:

std::vector<Object*> v;

    Object o (i);
    v.push_back(&o);

By something like this:

std::vector<std::shared_ptr<Object> > v;

    std::shared<Object> o(new Object(i));
    v.push_back(o);

If you do not know anything about shared pointers, I suggest you read up on them. It's very useful whenever you allocate objects with new. Also there are a few traps with what is called circular references (i.e. check out weak_ptr as well). But in this way you do not have to manage memory and you have good pointers.

If you prefer the solution with the Object by itself, it would be something like this:

std::vector<Object> v;

    Object o(i);
    v.push_back(o);

This way you avoid the heap, however, you make copies each time you push_back (or a move). So if your objects are big, that's not a good idea.

Also, within your object, if you end up having pointers, using smart pointers will help you greatly too. So that's anyway a good idea to learn about them.