使用没有虚拟的模板从基类调用派生类函数

Question

I need to generate some members/methods of a class with a script. I'm trying to break up this class in two, with base class being generated members, and derived class having hand coded members. However, I'm getting stuck in figuring out how to call derived member function D::f2() from the base class B::f1() .

Here is the simplified code:

#include <cstdio>

template <typename _T>
class B { 
public:
    void f3() {
        puts("okay");
    }
    void f1() {   
        f2();   // What C++ Magic to call f2() properly !!!
    }
};

class D : public B<D> {
public:
    void f2() {
        f3();
    }

};

int main() {
    D d;
    d.f1();
}

Is there any way, I can call D::f2() from B::f1() without using virtual functions ?

Added later:

If we do pointer manipulation, we will end up with injection, and I understand it's not a good idea, and I'll take the advice of not doing it. Let's stop that thread.

I am trying to find a solution using template only. I can generate any complex thing for the generated code. It can even be a several functors etc. However the hand coded written part should be hand-codable.

Answer 1

If you really really really want to do it:

static_cast<_T*>(this)->f2();

As people have mentioned, this is the curiously recuring template pattern !

Answer 2

This is a typical Curiously recuring template pattern . You can do:

template <typename _T>
class B { 
public:
     void f3() {
      puts("okay");
     }
     void f1() {      
      static_cast<_T>(this)->f2();
     }

};

Answer 3

A base class should have no notion of its children. Attempt to call a child method from base class is a sure sign of bad architecture. Virtual functions will not help you here by the way.

If you have to call a child's function from the base class you can do so just like you would do from any other function in your code. Still you will need an instance of the base class to call it on or alternatively you will have to static_cast the this pointer to a pointer of the child class type. This is a very bad idea!

Answer 4

您可以使用Curiously Recurring Template Pattern 。

Answer 5

There is another way, but at the cost of an ugly C style/reinterpret cast:

#include <cstdio>
#include <functional>


class B { 
public:
    typedef std::function<void (B*)> Function;    

    void f3() {
        puts("okay");
    }
    void f1() {   
        _func(this);
    }

    Function _func;
};

class D : public B 
{
public:
    D()
    {
        _func = (void (B::*)()) &D::f2; // Here is the awfull cast I hate to do
    }

    void f2() {
        f3();
    }

};

int main() {
    D d;
    d.f1();
}

http://ideone.com/yOR0xT

I find this a lot less clean than the CRTP , because you have no compile time check...