how to use the virtual destructor?

[sugarva]

Hi all,
I have a piece of code like this
constructor:

IPCClientDataTransfer::IPCClientDataTransfer (RWCString serviceName) :Valid(FALSE)
{
NSTcpProfile tcpProfile;
int clientPriority = 1;
tcpProfile.BlockingOnConnect = TRUE;
tcpProfile.Blocking = TRUE;
strcpy(tcpProfile.ServiceName, serviceName);
strcpy(tcpProfile.TcpHostName, "localhost");

this -> PClient = new IPCAMAClient (&tcpProfile, clientPriority);

// Check to see if the IPCAMAClient is a valid object
if (!this -> PClient -> isValid())
{
// The object is invalid, the connection was not established
delete this -> PClient;
this -> PClient = NULL;
}
else
{
// The Object is valid
this -> Valid = TRUE;
}
destructor:

IPCClientDataTransfer::~IPCClientDataTransfer ()
{
if (this -> PClient)
delete this -> PClient;
}

the destructor is not virtual.does this means that there will be memory leak?

[weaknessforcats]

There will be no leak in the IPCClientDataTransfer class.

However, if IPCClientDataTransfer has virtual functions and another class derives from IPCClientDataTransfer, you may have a leak.

In this case the derived class object is identified by either a base class reference or a base class pointer (simple C++ polymorphism). Without the virtual destructor in IPCClientDataTransfer, the destructor of the derived class will not be called when the pointer or reference to IPCClientDataTransfer is deleted.

[sugarva]

ok.thanks a lot.
there are no virtual functions in IPCClientDataTransfer.C class.
in this line
this -> PClient = new IPCAMAClient (&tcpProfile, clientPriority);

a new instance has been created for IPCAMAClient class.
but i dont think it is a derived class of IPCClientDataTransfer.C class.

whether still the memory leak problem exist because the IPCClientDataTransfer.C class destructor is not virtual?

[sugarva]

and one more info

IPCClientDataTransfer is wrapper class around IPCAMAClient.

[weaknessforcats]

From what I see the new IPCAMAClient object allocated in the IPCClientDataTransfer constructor will be deleted by the IPCAMAClient destructor. So you shouldn't leak.

I did notice that in one place you:

// The object is invalid, the connection was not established
delete this -> PClient;
this -> PClient = NULL;
}

but in ther destructor you:

if (this -> PClient)
delete this -> PClient;

It is not required to test for zero before deleting but it is important to zero after deleting in case you delete again. Deleting twice will crash the program.

You do not zero in the destructor. Somebody could call the destructor more than once and your prgram would crash.

In both places I would change to:

delete this->PClient;
this->PClient = 0;
 

[whodgson]

I was under the impresion that a virtual destructor is illegal.Is this wrong?

[Laharl]

Yes. Virtual constructors are illegal, but virtual destructors are not only legal but also very useful to deal with the inherent base class object created with derived class objects.

[whodgson]

Thanks......i need to re-read my books and do some more exercises on connstructors and destructors.

[sugarva]

thaks a lot.

you have said that IPCAMAClient destructor will delete the object.

but the destructor is
/************************************************** **************
Method: ~IPCAMAClient

Description: The destructor. Does nothing

Parameters: None

Returns: void
************************************************** **************/
IPCAMAClient::~IPCAMAClient( )
{
}

/************************************************** **************


it does nothing.
is it necessary that i should delete the object here and to zero that?

whether deleting the objects in two classes is necessary?

[weaknessforcats]

it does nothing.
is it necessary that i should delete the object here and to zero that?

whether deleting the objects in two classes is necessary?

Remember, in C++ constructors do not create objects and destructors do not delete objects.

Only the compiler can create and delete objects. As part of that process, when the object is created the compiler, as a courtesy, will call your constructor so you can initialize the already created object. Similarly, when the object is being deleted the compiler, again as a courtesy, will call your destructor so you can release any memory allocations you may have made.

Constructors and destructors are just functions like any other.

If you happen to call your destructor yourself, then any variables you allocated in the object will be released but your object is still there. Calling a destructor is a convenient way to release the current contents of an object when you intend to install new contents, like with an assignment operator overload.

If your class contains no variables allocated using the new operator, then you don't need a destructor at all.

[sugarva]

ok.thanks.
so,in your opinion there won't be any memory leak.right?

[weaknessforcats]

Again, if you do not use the new operator, there can never be a leak.

If you so use the new operator and your delete is in your destructor, then there is no leak.

If you use the new operator more than once without deleting the previous allocationm, then you will have a leak.