Question

Let’s say I have a C++ interface

class Iface
{
public:
    virtual ~Iface () {}
    virtual void foo () = 0;
    virtual void bar () = 0;
};

And I have some set of classes that needs to expose that on one side and implement it off somewhere else. I find that quite commonly I end up with a bunch of classes in the middle which essentially do something like this:

class InTheMiddleSomewhere
    : public Iface // amongst other things
{
public: // Iface
    virtual void foo () { if (impl) impl->foo (); }
    virtual void bar () { if (impl) impl->bar (); }
private:
    IfaceImpl* impl;
};

Which gets tiresome to write and maintain as the interfaces expand, proliferate and change.

Q: Is there a better (more or less automatic) way to implement a pass through for a complete interface than coding all that “if (impl) impl->…” stuff by hand?

Answer 1

You can bind the call into a function object, and then just pass through the function object (rather than making a delegate call for each member function of the interface).

Consider the following:

struct I
{
    virtual R1 f1(A1, B1, ..., Z1) = 0;
    virtual R2 f2(A2, B2, ..., Z2) = 0;
    .
    .
    virtual Rn fn(An, Bn, ..., Zn) = 0;
};

Now I have some implementation of I:

struct : I
{
    ...
} x, y, z;

So I can call x, y and zs function like:

Ri xri = x.fi(ai, bi, ..., zi);
Ri yri = y.fi(ai, bi, ..., zi);
Ri zri = z.fi(ai, bi, ..., zi);

or I can bind a call to a method of the I interface as follows:

function<Ri(I&)> g = bind(&I::fi, _1, ai, bi, ..., zi);

and then later:

Ri xri = g(x);
Ri yri = g(y);
Ri zri = g(z);

This works even if x, y and z are different classes, as long as they are derived from I.