C++ delete an object

Question

I am not experienced in handling of the memory in a C++ program, so I would like a piece of advice in that case:

I want to create a new Object in a function in a class which is essential till the end of the program. As far as I am concerned, if I use the operator new, I should sometimes delete it. Taking into account that it must be initialized inside a class, when and how must I finally delete it?

Answer 1

I suggest the smart pointer idiom

#include <memory>

struct X 
{
     void foo() { }
};

std::share_ptr<X> makeX() // could also be a class member of course
{
    return std::make_shared<X>();
}

int main()
{
     std::share_ptr<X> stayaround = makeX();

     // can just be used like an ordinary pointer:

     stayaround->foo();

     // auto-deletes <sup>1</sup>
}

If the pointer is truly a static variable, you can substitute a unique_ptr (which works similarly, but passes ownership on assignment; this means that the pointer doesn't have to keep a reference count)

Note To learn more about C++ smart pointers in general, see   smart pointers (boost) explained  

Note If you don't have the TR1/C++0x support for this, you can just use Boost Smartpointer

---

_{¹ unless you are leaking copies of the shared_ptr itself; that would be some strange use of smart pointers previously unseen :)}

Answer 2

You can use the smart pointer as suggested by Sehe or you can create a static object in the function and return a reference to it. You need not explictly delete the object, when the process terminates the object will be deleted. Like:

struct X {};

X& makeX() // could also be a class member of course
{
    static X x;
    return x;
}

int main()
{
     X& stayaround = makeX();
}

Answer 3

Edit: Using some sort of smart pointer is often a good idea, but I believe it is still essential to have a solid understanding of manual memory management in C++.

If you want an object in a class to persist until the end of the program, you can simply make it a member variable. From what you've said, there's nothing to suggest you need to use new or delete here, just make it an automatic variable. If you did want to use new and delete for practice, you should read up on constructors and destructors for a class (you can and will use new and delete outside of classes, but I'm trying to keep this relevant to your question). Here's one I prepared earlier:

class Foo
{
    public:
        Foo();  // Default constructor.
        ~Foo(); // Destructor.

    private:
        int *member;
}

Foo::Foo() // Default constructor definition.
{
    member = new int; // Creating a new int on the heap.
}

Foo::~Foo() // Destructor.
{
    delete member; // Free up the memory that was allocated in the constructor.
}

This is a simple example, but it will hopefully help you out. Note that the variable will only persist as long as the object is alive. If the object is destroyed or goes out of scope, the destructor will be called and the memory will be freed.

Answer 4

On most operating systems (in particular Linux), if you allocate an object pointer with new Object, and don't bother delete-ing because you'll need it till the program ends, no harm is really done. There is some memory leak inside your program (you can use valgrind to hunt such leaks) but the kernel will release all the memory used by a process when it has ended.

A better alternative is to have a singleton class for the application data, like e.g. QApplication in Qt, ahd construct a single instance in that class early in your main, and have that class contain a smart or dumb pointer to your Object. The destructor should delete that object.