C++ How to know when an object has been destroyed

If you want an object's lifetime to extend beyond the scope in which it's created, then that object has to be created with dynamic lifetime. You use new to do this:

std::vector<Foo*> foos;

{
    Foo* foo = new Foo;
    foos.push_back(foo);
}

The Foo object that new returns a pointer to will live until it is explicitly deleted. Note that std::vector will not do this for you. You must explicitly delete the objects pointed to by the pointers stored in your vector:

for (std::size_t i = 0; i < foos.size(); ++i) {
    delete foos[i];
}

Ideally you would use a smart pointer of some kind to manage your dynamic-lifetime objects, but the standard smart pointers std::unique_ptr and std::shared_ptr were not in C++98. std::auto_ptr was available, but that class is very easy to use incorrectly. It may be worth writing your own simple shared_ptr-like class to do this for you. It's not too complicated if you don't need to support things like weak pointers and atomic operations. Here's a very basic implementation:

template <typename T>
class shared_ptr
{
private:
    struct control_block
    {
        control_block(T* ptr)
            : ref_count_(1),
              ptr_(ptr)
        {}
        
        ~control_block()
        {
            delete ptr_;
        }
        
        size_t ref_count_;
        T* ptr_;
    };

    control_block* control_block_;
    
public:
    shared_ptr()
        : control_block_(NULL)
    {}

    shared_ptr(T* ptr)
        : control_block_(new control_block(ptr))
    {}
    
    shared_ptr(const shared_ptr& other)
        : control_block_(other.control_block_)
    {
        ++control_block_->ref_count_;
    }
    
    shared_ptr& operator=(shared_ptr other)
    {
        std::swap(control_block_, other.control_block_);
        return *this;
    }
    
    ~shared_ptr()
    {
        if (control_block_) {
            --control_block_->ref_count_;
            if (control_block_->ref_count_ == 0) {
                delete control_block_;
            }
        }
    }
    
    T& operator*() { return *control_block_->ptr_; }
    T* operator->() { return control_block_->ptr_; }
    
    bool operator==(const shared_ptr& other)
    {
        return control_block_ == other.control_block_;
    }
};

Live Demo

The basic premise is that all shared_ptrs for a given object hold a pointer to the same control_block. Whenever the shared_ptr is copied its control_block's reference count is incremented and whenever a shared_ptr is destroyed its control_block's reference count is decremented. If the reference count ever reaches zero it deletes the control block along with the pointed-to object.

In C++ you are responsible of life cycle of object. If you use

Foo foo;

foo will be destroyed at out of scope. So, you shouldn't use local variable. Use dynamic objects (for example):

Foo* foo = new Foo;
foos.push_back(foo);

It will work. And you are responsible for object destroying.

You could use give the vector to the foo itself and remove the pointer in the destructor. Basically the object itself does the bookkeeping of pointers.

#include <iostream>
#include <string>
#include <vector>

class Foo {
    std::vector <Foo *> *v;
    public:
    Foo(std::vector <Foo *> *v):  v(v){}
    void Speak(){
        std::cout << "ruff";    
    }
    ~Foo() {
        auto it = std::find(v->begin(), v->end(), this);
        if (it != v->end())
        {
            v->erase(it);
        }
    }
};

int main()
{
    std::vector<Foo*> foos;
    
    {
        Foo foo(&foos);
        foos.push_back(&foo);
        // foo is now dead 
    }
    std::cout << "length is " << foos.size() << '\n';
    for(size_t i = 0; i < foos.size(); i++){
        // uh oh
        foos[i]->Speak();   
    }
}

OUTPUT

➜  test ./a.out
length is 0

I would like to put my own answer here to present the realization of what I was unknowingly trying to write: Garbage Collection. And more importantly, on memory that is already automatically managed.

That took about 3 days to understand. I was creating a system of nodes and references in order to keep objects alive. Literally garbage collection...

Woopsies.

Why don’t you use std::vector<Foo> instead of std::vector<Foo*>? In the former way, i think there’s no way to prevent Foo object destroyed when it came out of scope - but when you push to vector, it will sit there until program terminate or we explicit remove.