c++ - retorna - punteros y matrices en c

¿Cómo se escribe un puntero al método que devuelve un puntero al método?

Question

Básicamente tengo la siguiente clase:

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

Los métodos stateA () y stateB () deberían poder devolver los punteros a stateA () y stateB (). Cómo tipear el método de estado?

Answer 1

EDITAR: njsf me demostró que estoy equivocado aquí. Sin embargo, es posible que encuentres el fundido estático más simple de mantener, así que dejaré el resto aquí.

No hay un tipo estático "correcto" ya que el tipo completo es recursivo:

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

Su mejor typedef void (StateMachine::*StateMethod)(); es usar typedef void (StateMachine::*StateMethod)(); luego haga el feo state = (StateMethod)(this->*state)();

La función PS boost::function requiere un tipo de devolución explícita, al menos desde mi lectura de los documentos : boost::function0<ReturnType>

Answer 2

Mi filosofía es no usar 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 ::.

Esto es casi seguro incorrecto:

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 definitivamente mucho más difícil de lo que parece a primera vista

Answer 3

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

Entonces dado:

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

¿Cuál es la sintaxis para statede typedef? Ni idea ... así que tratemos de asignarle algo no relacionado y ver lo que dice el compilador:

char c = StateMachine::stateA

El compilador dice:

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

Ahí está: "bool (StateMachine :: *) (int)" es nuestro typedef.

Answer 4

Usando simplemente 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

GotW # 57 dice que use una clase proxy con una conversión implícita para este 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 puntos fuertes principales:

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

2. Su maquinaria es transparente: obtienes la sintaxis natural para el que llama / usuario y la sintaxis natural para el propio "estado de retorno" de la función; declaración.

3. Probablemente no tenga gastos generales: en los compiladores modernos, la clase de proxy, con su almacenamiento y funciones, debe alinearse y optimizarse hasta desaparecer.