Question

I have a class messenger which relies on a printer instance. printer is a polymorphic base class and the actual object is passed to the messenger in the constructor.

For a non-polymorphic object, I would just do the following:

class messenger {
public:
    messenger(printer const& pp) : pp(pp) { }

    void signal(std::string const& msg) {
        pp.write(msg);
    }

private:
    printer pp;
};

But when printer is a polymorphic base class, this no longer works (slicing).

What is the best way to make this work, considering that

1. I don’t want to pass a pointer to the constructor, and
2. The printer class shouldn’t need a virtual clone method (= needs to rely on copy construction).

I don’t want to pass a pointer to the constructor because the rest of the API is working with real objects, not pointers and it would be confusing / inconsistent to have a pointer as an argument here.

Under C++0x, I could perhaps use a unique_ptr, together with a template constructor:

struct printer {
    virtual void write(std::string const&) const = 0;
    virtual ~printer() { } // Not actually necessary …
};

struct console_printer : public printer {
    void write(std::string const& msg) const {
        std::cout << msg << std::endl;
    }
};

class messenger {
public:
    template <typename TPrinter>
    messenger(TPrinter const& pp) : pp(new TPrinter(pp)) { }

    void signal(std::string const& msg) {
        pp->write(msg);
    }

private:
    std::unique_ptr<printer> pp;
};

int main() {
    messenger m((console_printer())); // Extra parens to prevent MVP.

    m.signal("Hello");
}

Is this the best alternative? If so, what would be the best way in pre-0x? And is there any way to get rid of the completely unnecessary copy in the constructor? Unfortunately, moving the temporary doesn’t work here (right?).

Answer 1

There is no way to clone polymorphic object without a virtual clone method. So you can either:

• pass and hold a reference and ensure the printer is not destroyed before the messenger in the code constructing messenger,
• pass and hold a smart pointer and create the printer instance with new,
• pass a reference and create printer instance on the heap using clone method or
• pass a reference to actual type to a template and create instance with new while you still know the type.

The last is what you suggest with C++0x std::unique_ptr, but in this case C++03 std::auto_ptr would do you exactly the same service (i.e. you don’t need to move it and they are otherwise the same).

Edit: Ok, um, one more way:

• Make the printer itself a smart pointer to the actual implementation. Than it’s copyable and polymorphic at the same time at the cost of some complexity.