Static Polymorphism for method and object selection in C++

Question

Trying to get compile time method and object selection without base class and virtual calls.

Here is the case:

struct A {
    void f1()const { cout << "A::f1" << endl;}
    void f2()const { cout << "A::f2" << endl;}
};

struct B {
    void f1()const { cout << "B::f1" << endl;}
    void f2()const { cout << "B::f2" << endl;}
};

class Holder {
    A* _a = nullptr;
    B* _b = nullptr;
public:
    Holder(A* a): _a(a) {}
    Holder(B* b): _b(b) {}
    void f1()const {
        if(_a)       _a->f1();
        else if(_b)  _b->f1();
    }
    void f2()const {
        if(_a)       _a->f2();
        else if(_b)  _b->f2();
    }
};

void f(const Holder& h) {
    h.f1();
}

int main() {
    B obj;
    Holder h(&obj);
    f(h);
}

http://coliru.stacked-crooked.com/a/4b5acec6866cfd4e

Suppose there are very few classes like A and B but there may be a lot of functions like f1 and f2.

Holder needs to call function on the actual object that it holds, without polymorphism and without a need for inheritance / shared interface for A and B.

Looking for a nice way to do something like:

class Holder {
    A* _a = nullptr;
    B* _b = nullptr;
public:
    Holder(A* a): _a(a) {}
    Holder(B* b): _b(b) {}
    // below is pseudo code!
    void call<function>()const {
        if(_a)
            _a->function(); // function is known in compile time, sort of...
        else if(_b)
            _b->function();
    }

    void f1()const { call<f1>(); }
    void f2()const { call<f2>(); }
};

Any idea?

macro?
template?
other trick?

*"without polymorphism and without a shared interface"* Why? — wally, Nov 01 '16 at 12:14
Still you need a base class, but did you check that? https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern — Deniz, Nov 01 '16 at 12:17
Seems like you might want to use [some tricks from c](http://stackoverflow.com/questions/524033/how-can-i-simulate-oo-style-polymorphism-in-c)? — wally, Nov 01 '16 at 12:21
To be clear only relation between classes are names of the functions? — Logman, Nov 01 '16 at 12:23
Do you want to make `Holder` a template? If not, you'd need some kind of type erasure. — TartanLlama, Nov 01 '16 at 12:23
@flatmouse, no. C++ has some sophisticated methods of compile time polymorphism. The whole point is to *avoid* the runtime cost of dynamic dispatch. — StoryTeller - Unslander Monica, Nov 01 '16 at 12:27
@StoryTeller Fair point, but would you say this cost has been avoided in the accepted answer? — wally, Nov 01 '16 at 13:28
@flatmouse, Yes. `boost::variant` doesn't need to lookup an arbitrary function, since it knows the entire set of functions that can be called *at compile time*. That (meta-programmed) code can therefore be optimized by the compiler. — StoryTeller - Unslander Monica, Nov 01 '16 at 13:38
@flatmouse, It's a statically bound call, unless the function itself is declared virtual in either `A` or `B` (But even than it will be a virtual call only when the variant *holds* the type where it's virtual). — StoryTeller - Unslander Monica, Nov 01 '16 at 13:42

score 7 · Accepted Answer · answered Nov 01 '16 at 12:30

You can use a variant. This reduces the storage from N to 1 pointer plus 1 int, and doesn't require changing anything except Holder:

#include <boost/variant.hpp>

struct f1visitor
{
    typedef void result_type;
    template<typename T>
    void operator()(T* const t) const { t->f1(); }
};

struct f2visitor
{
    typedef void result_type;
    template<typename T>
    void operator()(T* const t) const { t->f2(); }
};

class Holder {
    boost::variant<A*, B*> _ptr;
public:
    Holder(A* a): _ptr(a) {}
    Holder(B* b): _ptr(b) {}
    void f1()const {
        boost::apply_visitor(f1visitor(), _ptr);
    }
    void f2()const {
        boost::apply_visitor(f2visitor(), _ptr);
    }
};

With new enough C++ you may be able to use std::variant instead.

With c++14, you may even use generic lambda instead of manual visitor. — Jarod42, Nov 01 '16 at 12:39
Beautiful! merging this answer with @Jarod42 comment: [http://coliru.stacked-crooked.com/a/c38749b4b30457cc](http://coliru.stacked-crooked.com/a/c38749b4b30457cc) — Amir Kirsh, Nov 01 '16 at 13:17

score 1 · Answer 2 · answered Nov 03 '16 at 00:22

Working on the solution proposed by John Zwinck and trying to reduce the boilerplate of the repeated calls to boost::apply_visitor(f1visitor(), _ptr); I've progressed to this code:

struct A {
    void f1()const { cout << "A::f1" << endl;}
    void f2(const std::string& s)const { cout << "Hello " << s << endl;}
    int  f3(int i, int j, int k)const { return i + j + k; }
};

struct B {
    void f1()const { cout << "B::f1" << endl;}
    void f2(const std::string& s)const { cout << "Shalom " << s << endl;}
    int  f3(int i, int j, int k)const { return i * j * k; }
};

class Holder {
    boost::variant<A*, B*> _ptr;
public:
    template<typename T> Holder(T* ptr): _ptr(ptr) {}
    CREATE_DELEGATE_FUNCTION_0 (void, f1)
    CREATE_DELEGATE_FUNCTION   (void, f2, const std::string&)
    CREATE_DELEGATE_FUNCTION   (int,  f3, int, int, int)
};

void f(const Holder& h) {
    h.f1();
    h.f2("world");
    cout << h.f3(2, 3, 4) << endl;
}

int main() {
    A obj1;
    f(Holder(&obj1));
    B obj2;
    f(Holder(&obj2));
}

(It's to be noted that types match in calls to CREATE_DELEGATE_FUNCTION is checked at compile time).

Output

A::f1
Hello world
9
B::f1
Shalom world
24

The macros behind this "magic":

#define NUM_ARGS(...) NUM_ARGS_(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#define NUM_ARGS_(_10, _9, _8, _7, _6, _5, _4, _3, _2, _1, N, ...) N

#define CREATE_DELEGATE_FUNCTION_0(ret_type, name) \
   ret_type name (void) const {  \
   return boost::apply_visitor([](auto* const t) \
   {return t-> name ();}, _ptr); }

#define CREATE_DELEGATE_FUNCTION_1(ret_type, name, type1) \
   ret_type name (type1 a) const {  \
   return boost::apply_visitor([&a](auto* const t) \
   {return t-> name (a);}, _ptr); }

#define CREATE_DELEGATE_FUNCTION_2(ret_type, name, type1, type2) \
   ret_type name (type1 a, type2 b) const {  \
   return boost::apply_visitor([&a, &b](auto* const t) \
   {return t-> name (a, b);}, _ptr); }

#define CREATE_DELEGATE_FUNCTION_3(ret_type, name, type1, type2, type3) \
   ret_type name (type1 a, type2 b, type3 c) const {  \
   return boost::apply_visitor([&a, &b, &c](auto* const t) \
   {return t-> name (a, b, c);}, _ptr); }

#define M_CONC(A, B) M_CONC_(A, B)
#define M_CONC_(A, B) A##B

#define CREATE_DELEGATE_FUNCTION(ret_type, name, ...) \
   M_CONC(CREATE_DELEGATE_FUNCTION_, NUM_ARGS(__VA_ARGS__)) (ret_type, name, __VA_ARGS__)

Code: http://coliru.stacked-crooked.com/a/834c9400a31defb6

Static Polymorphism for method and object selection in C++

Any idea?

2 Answers2

Output

The macros behind this "magic":