c ++: ¿La variable del objeto no puede evaluarse, pero la variable de referencia al mismo objeto sí?

Question

Ok, esto es muuuy raro ... creo. Lo que quiero decir con el título es:

dentro de la función act () de un objeto actionHandler que tengo:

state->getHumanPieces();

Lo que me da una violación de dirección de algún tipo, aparentemente 'esto' no tiene una variable 'estado' inicializada ... Sucede que esta clase actionHandler tiene una variable estática, que es un puntero a una instancia de sí misma, llamado 'controlador' ... y si lo hago:

handler->state->getHumanPieces();

Funciona perfectamente. Para que esto sea aún más claro:

Ese puntero 'handler' apunta a la única instancia de actionHandler existente en todo el programa (patrón singleton). Básicamente, cuando ejecuto esta función act () desde mi objeto actionHandler, no me permite acceder a la variable 'estado', PERO si desde ese objeto, intento acceder a la misma variable a través de un puntero al mismo objeto, esta bien ?? No entiendo lo que está pasando ... No estoy seguro si es claro, probablemente un poco confuso, pero espero que sea comprensible ...

Por cierto, el depurador VS08 muestra lo que quiero decir:

this: 0x000000 {state=???}
   handler: someAddress {state= someAddress}
      handler:...
      state:...
state:  CXX0030: ERROR:  expression cannot be evaluated

Espero que eso sea más claro, es la pequeña estructura de árbol que aparece en la pequeña ventana donde se muestran los valores actuales de las variables (Autos).

EDITAR: Entiendo que este puntero es nulo, simplemente no entiendo cómo puede ser nulo. Publicaré un código:

actionHandler.h:

class gameState;

class actionHandler
{ 
public:
        static actionHandler* Instance(){return handler;}
    void act(int,int);
private:
    actionHandler();
    static actionHandler* handler;
    gameState *state;
};

actionHandler.cpp:

actionHandler* actionHandler::handler = new actionHandler();

actionHandler::actionHandler()
{
        state = gameState::Instance();
}
void actionHandler::act(int x, int y)
{
    state->getHumanPieces();
}

ahora, en gameState.h tengo una estructura similar (singleton) y una variable privada actionHandler *, que se inicializa en:

gameState::gameState()
{
    handler = actionHandler::Instance();
}

y también una función getHandler () que devuelve el controlador. Todo esto debería inicializarse en main.cpp:

gameState *currState = gameState::Instance();
actionHandler *handler = currState->getHandler();

y luego se usa:

handler->act(event->button.x,event->button.y);

main.cpp está escrito en estilo .c simple, sin encabezado, así que sí, supongo que la función que llama al controlador es estática ... sin embargo, también hago llamadas al puntero gameState *, que supuestamente funciona exactamente en de la misma manera que actionHandler * one ... Espero que esto lo aclare más.

Answer 1

Parece un caso de fiasco de orden de inicialización estático descrito aquí . Sus dos constructores de objetos estáticos dependen unos de otros de forma circular, lo cual es muy extraño.

Answer 2

Su puntero this es nulo.

Algo como esto está sucediendo:

actionHandler* actObj = 0;
actObj->act(); // ERROR access violation

Answer 3

Asegúrese de que el objeto actionHandler al que está llamando act () esté inicializado. Me parece que se está llamando a act () en un puntero nulo .

Answer 4

¿Sus métodos actionHandler () o act () son estáticos?

Porque si es así, es perfectamente normal que su puntero este sea NULL porque los métodos estáticos no se invocan desde una instancia particular de un objeto.

Por ejemplo, tome un objeto que se vea así:

class CThing
{
public:
    static void actionHandler();
    void act();
protected:
    static CThing* handler;
    CState state;
}

Si un puntero de función en CThing :: actionHandler () se pasa a una clase de terceros para recibir una notificación de algo, cuando esta clase llama al método CThing :: actionHandler () para notificarle (llamando a: CThing :: actionHandler (); y no ptrThing- > actionHandler () como lo haría si el método actionHandler no fuera estático), no podrá acceder a este puntero ni al variable de estado desde dentro de actionHandler (o cualquier llamada posterior realizada desde dentro de actionHandler) porque no hay este puntero, no hay ningún objeto actual.

Es por eso que al usar el handler- > state- > getHumanPieces () funciona, porque ahora, en realidad, se está refiriendo a una instancia de la clase CThing (handler) y no a la definición de clase en sí.

Espero haber sido lo suficientemente claro ... Si no, no dude en pedir precisiones.