Cómo escribir un puntero al método que devuelve un puntero al método?

Question

Básicamente tengo la clase siguiente:

class StateMachine { 
... 
StateMethod stateA(); 
StateMethod stateB(); 
... 
}; 

La métodos stateâ() y stateB() debe ser punteros capaces de retorno a stateâ() y stateB(). Cómo escribir el método StateMethod?

Answer 1

GotW #57 dice usar una clase proxy con una conversión implícita para este mismo propósito.

struct StateMethod; 
typedef StateMethod (StateMachine:: *FuncPtr)(); 
struct StateMethod 
{ 
    StateMethod(FuncPtr pp) : p(pp) { } 
    operator FuncPtr() { return p; } 
    FuncPtr p; 
}; 

class StateMachine { 
    StateMethod stateA(); 
    StateMethod stateB(); 
}; 

int main() 
{ 
    StateMachine *fsm = new StateMachine(); 
    FuncPtr a = fsm->stateA(); // natural usage syntax 
    return 0; 
}  

StateMethod StateMachine::stateA 
{ 
    return stateA; // natural return syntax 
} 

StateMethod StateMachine::stateB 
{ 
    return stateB; 
} 

Esta solución tiene tres principales fortalezas:

1. Resuelve el problema según sea necesario. Mejor aún, es seguro y portátil.

2. Su maquinaria es transparente: Se obtiene la sintaxis natural para la persona que llama /usuario, y la sintaxis natural para la propia función de "retorno stateâ;" declaración.

3. Probablemente tiene cero sobrecarga: en los compiladores modernos, la clase de proxy, con su almacenamiento y funciones, debe en línea y optimizar en nada.

Answer 2

Mi filosofía es no utilizar punteros de función de miembro sin formato. Ni siquiera sé realmente cómo hacer lo que quieres usando puntero sin formato typedef, la sintaxis es horrible. Me gusta usar la función boost ::.

Ésta es casi ciertamente equivocada:

class X 
{ 
    public: 
    typedef const boost::function0<Method> Method; 

    // some kind of mutually recursive state machine 
    Method stateA() 
    { return boost::bind(&X::stateB, this); } 
    Method stateB() 
    { return boost::bind(&X::stateA, this); } 
}; 

Este problema es, sin duda mucho más duro que aparece a simple vista

Answer 3

EDIT: njsf me resultó ser malo aquí. Sin embargo, es posible que encuentres el fundido estático más simple de mantener, así que dejaré el resto aquí.

no hay 'correcta' de tipo estático ya que el tipo completo es recursivo:

typedef StateMethod (StateMachine::*StateMethod)(); 

Su mejor opción es utilizar typedef void (StateMachine::*StateMethod)(); luego hacer el feo PS state = (StateMethod)(this->*state)();

: boost::function requiere una explícita tipo de devolución, al menos desde mi lectura de docs: boost::function0<ReturnType>

Answer 4

Utilizando sólo typedef:

class StateMachine { 

public: 

    class StateMethod;  
    typedef StateMethod (StateMachine::*statemethod)(); 

    class StateMethod { 

    statemethod method; 
    StateMachine& obj; 

    public: 

    StateMethod(statemethod method_, StateMachine *obj_) 
     : method(method_), obj(*obj_) {} 

    StateMethod operator()() { return (obj.*(method))(); } 
    }; 

    StateMethod stateA() { return StateMethod(&StateMachine::stateA, this); } 

    StateMethod stateB() { return StateMethod(&StateMachine::stateB, this); } 

};  

Answer 5

Nunca puedo recordar la declspec función horrible, C++, por lo que cada vez que tengo que averiguar la sintaxis que describe una función miembro, por ejemplo, sólo Inducir un error de compilador intencional que generalmente muestra la sintaxis correcta para mí.

Así que dado:

class StateMachine { 
    bool stateA(int someArg); 
}; 

Cuál es la sintaxis para typedef de stateâ? Ni idea .. así que vamos a tratar de asignarle algo no relacionado y ver lo que el compilador dice:

char c = StateMachine::stateA 

compilador dice:

error: a value of type "bool (StateMachine::*)(int)" cannot be used to initialize 
     an entity of type "char" 

No es: "bool (StateMachine :: *) (int) "es nuestro typedef.