Question

Consider the below class

class Forwarder : public Base
{
private:
     Base* dest;
     Forwarder* next;
public:
    explicit Forwarder(Base* dest, Forwarder* next)
        : dest(dest), next(next) {}
    ~Forwarder() {
        if (next) delete next;
        delete dest;
    }

    void DoStuff() {
        if (next) next->DoStuff();
        dest->Process();
    }
};

Its purpose is to create a forwarding chain for events, so if DoStuff gets called at the base it will propagate throughout the chain, notifying others. I want to use this for sending output to various streams. Anyway, a typical way to create a chain would be like:

Forwarder f(new First, new Forwarder(new SomeOther, new Forwarder(new YouGetTheIdea, NULL)));

This is a really convenient way of constructing a chain, but it’s dangerous and vulnerable to memory leaks because the compiler can shuffle things around. Is there a safer way to construct chains like I’m wanting (preferably retaining the lean syntax)?

Answer 1

Instead of using new explicitly, use a function which returns a smart pointer, and make the constructors take in smart pointers.

For example,

class Forwarder : public Base
{
private:
     shared_ptr<Base> dest;
     shared_ptr<Forwarder> next;
public:
    explicit Forwarder(shared_ptr<Base> dest, shared_ptr<Forwarder> next)
        : dest(dest), next(next) {}

    void DoStuff() {
        if (next) next->DoStuff();
        dest->Process();
    }
};

And then use it as so:

Forwarder f(make_shared<First>(), make_shared<Forwarder>(make_shared<SomeOther>(), make_shared<Forwarder>(make_shared<YouGetTheIdea>(), shared_ptr<Forwarder>(NULL))));

you could also use unique_ptr instead, if you implement make_unique() (or equivalent factory methods)