Why doesn't the C++ default destructor destroy my objects?

Question

The C++ specification says the default destructor deletes all non-static members. Nevertheless, I can't manage to achieve that.

I have this:

class N { public:     ~N() {         std::cout << "Destroying object of type N";     } };  class M { public:     M() {         n = new N;     } //  ~M() { //this should happen by default //      delete n; //  } private:     N* n; }; 

Then this should print the given message, but it doesn't:

M* m = new M(); delete m; //this should invoke the default destructor 

Answer 1

What makes you think the object n points to should be deleted by default? The default destructor destroys the pointer, not what it's pointing to.

Edit: I'll see if I can make this a little more clear.

If you had a local pointer, and it went out of scope, would you expect the object it points to to be destroyed?

{     Thing* t = new Thing;      // do some stuff here      // no "delete t;" } 

The t pointer is cleaned up, but the Thing it points to is not. This is a leak. Essentially the same thing is happening in your class.

Answer 2

Imagine something like this:

class M { public:     M() { } //  ~M() {        // If this happens by default //      delete n; // then this will delete an arbitrary pointer! //  } private:     N* n; }; 

You're on your own with pointers in C++. No one will automatically delete them for you.

The default destructor will indeed destroy all member objects. But the member object in this case is a pointer itself, not the thing it points to. This might have confused you.

However, if instead of a simple built-in pointer, you will use a smart pointer, the destruction of such a "pointer" (which is actually a class) might trigger the destruction of the object pointed to.