template <class TClass> class TCallbackFunctorClassMemberFunction
{
private:
    void (TClass::*fpt)(void); // pointer to member function
    TClass* pt2Object; // pointer to object
public:
    TCallbackFunctorClassMemberFunction(TClass* _pt2Object, void (TClass::*_fpt)(void))
    {
    pt2Object = _pt2Object;
    fpt=_fpt;
    };
// override operator "()"
    virtual void operator()(void)
        { return (*pt2Object.*fpt)();}  // execute member function
    virtual void setCallBack(void(TClass::*_fpt)(void)) //change the callback pointer
        { fpt=_fpt;}
};
classA
{
protected:
    TCallbackFunctorClassMemberFunction<classA>* pfMethod;
public:
    virtual classA(void){
        // init the pointer to method to execute in state machine
        pfMethod = new TCallbackFunctorClassMemberFunction<classA>(this,(void (classA::*)(void))&classA::Idle)
    }
    virtual void Idle(void){
    }
    virtual void MethA(void){
        //execute some code if ok set the next method
        pfMethod->setCallBack( (void (classA::*)(void))&classA::MethB);
        //
    }
    virtual void MethB(void){
        //execute some code
        pfMethod->setCallBack( (void (classA::*)(void))&classA::MethC);

    }
    virtual void MethC(void){
        //execute some code and return in Idle state
        pfMethod->setCallBack( (void (classA::*)(void))&classA::Idle);
    }
    virtual void OnTick(){
        (*pfMethod)();
    }
    virtual void Run(){
        //init the state machine to the first method to execute.....
        pfMethod->setCallBack( (void (classA::*)(void))&classA::MethA);
    }

}



classB: public classA
{
public:
    classB():classA();
    void MethA(void){
        //execute the same method of classA
        classA::MethA();
    }
    void MethB(void){
        //execute the same method of classB but changes the next step
        //of state machine
        classA::MethB();
        pfMethod->setCallBack( (void (classA::*)(void))&classB::MethInserted);
    }
    void MethInserted(void){
        //do something different
        //but set the next step to the one of base state machine
        pfMethod->setCallBack( (void (classA::*)(void))&classB::MethC);
    }

    void MethC(void){
        //return to do the original state machine...
        classA::MethC();
    }
    void OnTick(){
        (*pfMethod)();
    }
    void Run(){
        //init the first method to execute
        pfMethod->setCallBack( (void (classA::*)(void))&classB::MethA);
    }

};

int main()
{
    classA* pA = new classA();
    classB* pB = new classB();
    pb->Run();
    while(1)
    {
    pB->OnTick();
    }
}