Thread: destructors

howdy,
i'm a little confused about this destructor thing. im trying to get a handle on two concepts and they seem to over lap, is
~cat()
{
}

the same as

delete cat();

or in other words can a class be destructed using delete?

and can an object created

int * stuff = new int;

be destructed

~stuff;

it all seems so complicated.

thanks
M.R.

A destructor is implicitly (you don't have to do it) called when the object goes out of scope. The purpose of the destructor is to deallocate any dynamic memory that was created by the object.
here's a short example:

Code:

#include <iostream.h>

class Object {
private:
 int *array;

public:
 // the constructor
 Object() { 
  // allocate a dynamic array
  array = new int[5]; 
  cout << "Object created\n";
 };

 // the destructor
 ~Object() { 
  // delete the array
  delete[] array;
  cout << "Object destroyed\n";
 };
};

void main() {
 Object Obj;
}

you never call the destructor, but the code runs when the object falls out of scope (in this case the program ends).

You can call the deconstructor but it's best not to. Deconstructors are automatically called when the object goes out of scope. Scope is simply anything between two { and } brackets. For example:

Code:

{
       int MyVariable = 1;
}

MyVariable += 2; // error. MyVariable is in another scope

So, if you happen to want to destroy an object sooner than say, the end of a function, instead of calling the deconstructor explicitly you can call it implicitly with brackets.

Code:

voidMyFunc (int X, int Y)
{
   {
        MyObject OBJA;
        OBJA.Z = (X*Y);
        // ... blahblah
   } // MyObject's destructor is called
   // ... blahblah
   return;
}

deletes are usually found in constructors while news in constructors. That way all the cleaning and regaining of space is done together.

one more little thing.
if you ever call delete on an object that has
1.)not been created.
2.)has allready been deleted.

your program will become unstable
the next time the deleted object is used it will likely crash or worse.

howdy,
Thanks for your help!
now let me see if i understand -
like <rmullen3> said the destructor for an object is implicitly (but should never be explicitly) called when the object and/or class goes out of scope, i assume this does not apply to object created with the "new" operator based on what <taylorguitarman> said by calling "delete" in the class object destructor function. and if delete is misused it can cause major havoc.
i think i'm getting the hang of this now.

thanks
M.R.

As mentioned above it is a good idea to check if a pointer is null before trying to delete it.
so this simple code helps

Code:

if(NULL != pointer) {
 delete pointer;
 pointer = NULL;
}

you should also set the pointer to null after you have deleted it because technically it still points the memory location and you could accidently use it.