How to easily override multiple overloaded methods?

Question

Let's say I have an interface and a class implementing it, like this:

class IPrinter
{
public:
    virtual void print(int i, int base = 10) = 0;
    virtual void print(char c) = 0;
    virtual void print(char *s) = 0;
    virtual void print(float f) = 0;
    virtual void print(double d) = 0;
    virtual ~IPrinter() = default;
private:
    ...
}

class Printer : public IPrinter
{
public:
    void print(int i, int base = 10) override {...}
    void print(char c) override {...}
    void print(char *s) override {...}
    void print(float f) override {...}
    void print(double d) override {...}
private:
    ...
}

And then I decide to add a simple decorator class, like this:

class SwitchablePrinter : public IPrinter
{
private:
    IPrinter& _printer;
    bool _enabled;
    ...
public:
    SwitchablePrinter(IPrinter& p) : 
        _printer(p), 
        _enabled(true) 
    {
    }

    void print_enable(bool on) { _enabled = on; }

    void print(int i, int base = 10) override
    {
        if (_enabled)
            _printer.print(i, base);
    }
    void print(char c) override
    {
        if (_enabled)
            _printer.print(c);
    }
    void print(char *s) override
    {
        if (_enabled)
            _printer.print(s);
    }
    void print(float f) override
    {
        if (_enabled)
            _printer.print(f);
    }
    void print(double d) override
    {
        if (_enabled)
            _printer.print(d);
    }
}

Now, all this is pretty simple and straightforward. The problem is that there is a lot of code duplication in the SwitchablePrinter implementation. I was wondering, that if there was a way to write a generic method 'print' for all overloaded methods in the base class, like this:

(pseudo-code)
void print({any args})
{
    if (_enabled)
        _printer.print({any args});
}

I think there may be a solution using templates, but I am not very experienced with using them and need advice.

No, there is none. Your code also will not do as you wish, you need to add virtual in Printer to override the functions. You could use boost::variant and one function instead of all those overloads. — Klemens Morgenstern, Oct 19 '15 at 11:57
@KlemensMorgenstern, "you need to add virtual in Printer" no, not really. — SingerOfTheFall, Oct 19 '15 at 12:00
Ah, because of the override you can skip the virtual? Nice, I didn't know that. — Klemens Morgenstern, Oct 19 '15 at 12:11
@KlemensMorgenstern You never needed it in the first place. A function will be virtual if any base class has a virtual function with the same signature. Regardless of whether you delcare it in subclass `virtual`, `override` or both or neither. — Rostislav, Oct 19 '15 at 12:14
@KlemensMorgenstern: You obviously don't understand the type-system of C++. — Lightness Races in Orbit, Oct 19 '15 at 12:22

Sergey Kalinichenko · Accepted Answer · 2015-10-19T14:50:20.143

Although there is no mechanism to override multiple member functions at once, you can simplify your task and reduce code duplication by providing a private variadic member function template that forwards the call to the proper overload of the wrapped _printer, like this:

private:
    template <class ... T>
    void print_impl(T ... vals) {
         if (_enabled)
             _printer.print(vals...);
         else
             cout << "disabled" << endl;
    }
public:
    void print(int i, int r) override {
        print_impl(i, r);
    }
    void print(float f) override {
        print_impl(f);
    }
    void print(double d) override {
        print_impl(d);
    }
    void print(char* s) override {
        print_impl(s);
    }
    void print(char c) override {
        print_impl(c);
    }

Demo.

This is only a slight improvement on the original, because the forwarding logic of print_impl is so simple. When the logic becomes more complex, payoff from sharing the code increases.

To handle the `int` case, how about making `print_impl` be variadic? It adds minimal syntactic overhead if we aren't worried about perfect forwarding. — Vaughn Cato, Oct 19 '15 at 14:43
@VaughnCato You are right, that makes for a much better implementation. Thank you very much! — Sergey Kalinichenko, Oct 19 '15 at 14:50

score 0 · Answer 2 · edited May 23 '17 at 12:23

The obvious thing to try is to replace the implementations in SwitchablePrinter with

template<typename T>
void print(T t) override
{
    if (_enabled)
        _printer.print(t);
}

(ignoring that there's a problem with the integer printing method.)

But this doesn't work, because member function templates cannot be virtual: Can a C++ class member function template be virtual?. (See the most upvoted answer, rather than the accepted one.) So your current implementation of SwitchablePrinter is the best, as far as I can see.

How to easily override multiple overloaded methods?

2 Answers2