c++ delete object referenced by two pointers

Question

I am just curious if there is an elegant way to solve following problem in c++:

I have a simulator app which contains several components connected by channels. The channels may be either network channels (two instances of the app are needed) or dummy local channel. There are two interfaces: IChannelIn and IChannelOut and two corresponding variables:

IChannelIn* in;
IChannelOut* out;

The DummyChannel is both IChannelIn and IChannelOut. It just copies input to output. There is also TCPChannelIn: public IChannelIn and separate TCPChannelOut: public IChannelOut.

Now, according to user's choice , I either create one DummyChannel

DummyChannel* d = new DummyChannel;
in = d;
out = d;

or two separate objects: in = new TCPChannelIn; out = new TcpChannelOut

The question is: what should the destructor do?

~App::App()
{
    delete in;
    delete out;
}

ends in an error because delete in; deleted also the dummy channel d so that delete out deletes already deleted thing.

Is there an elegant way out of this?

Answer 1

if (in == out) {
    delete in;
}
else {
    delete in;
    delete out;
}

?

Answer 2

Rule of thumb: match your news with your deletes.

~App::App()
{
    delete out;
    // the next line tries to free
    // memory no longer in the app's
    // control invoking UB
    delete in;
}

Here, you run into the classic double-free problem.

~App::App()
{
    if (in != out)
    {
        delete out;
    }
    // if in == out the out object is not deleted
    // for a non trivial object this tantamounts to
    // leaking resources held by TCPChannelOut other
    // than d
    delete in;
}

The only solution seems to be to use a smart reference counted pointer.

Answer 3

You'll need something along the lines of:

~App::App()
{
    if (in != out)
    {
        delete out;
    }
    delete in;
}

As when the channels are different the pointers will be different.

However, as danatel has pointed out in the comments in and out are not comparable. A safe (but inelegant) solution would be to use a dummy flag. Set if in and out are set to the dummy channel, the destructor would become:

~App::App()
{
    if (!dummy)
    {
        delete out;
    }
    delete in;
}

Though I wouldn't be happy with this.

The only other solution I can see at the moment is to change the definitions of IChannelIn and IChannelOut so that they can be compared safely.

Answer 4

If you are using boost you could consider using the boost::shared_ptr This will automatically delete the object when the last instance is released.

Answer 5

I always think of object ownership at design time:

• who creates the object?
• Who owns (therefore deletes the object)?
• How can I avoid to use a reference to an object that is already destroyed (or how can I determine whether a referenced object is still valid or not)?

When trying to answer these questions I determine the way to implement it, too (destructors, smart pointers, etc.).

Answer 6

How does your class know that this is a freestore pointer? E.g. what speaks against the following code?

DummyChannel d;
in = &d;
out = &d;

This is an entirely sensible piece of code but your destructor will crash when trying to delete either of the pointers.

Long story short: reclaiming resources is the job of whoever has allocated the resources in the first place. If your class gets passed a pointer, the class cannot know and does not care about deallocation. This is strictly the responsability of the caller.

Elegant ways to solve this dilemma without making the client to a lot of work are smart pointers, as mentioned before.

Answer 7

Don't forget to make your IChannelIn and IChannelOut destructors virtual. If the destructors are not virtual the TCPChannel or DummyChannel destructors will not get called when the IChannel destructors are called (i.e. when the IChannel ptr contents are deleted).