c ++: La variable d'objet ne peut pas être évaluée, mais une variable de référence à un même objet peut?

Question

Ok, c’est très bizarre… je pense. Ce que je veux dire avec le titre est:

à l'intérieur de la fonction act () à partir d'un objet actionHandler que j'ai:

state->getHumanPieces();

Ce qui me donne une violation d'adresse de quelque sorte, apparemment 'this' n'a pas de variable 'state' initialisée ... Il se trouve que cette classe actionHandler a une variable statique, qui est un pointeur sur une instance de lui-même, appelé 'gestionnaire' ... et si je le fais:

handler->state->getHumanPieces();

Cela fonctionne parfaitement .. Pour que cela soit encore plus clair:

Ce pointeur 'handler' pointe vers la seule instance d’actionHandler existant dans l’ensemble du programme (motif singleton). Ainsi, lorsque je lance cette fonction act () à partir de mon objet actionHandler, il ne me permet pas d'accéder à la variable 'state', MAIS si, à partir de cet objet, j'essaie d'accéder à la même variable via un pointeur sur le même objet, est ok ?? Je ne comprends pas ce qui se passe .. Je ne sais pas si c'est clair, c'est un peu déroutant, mais j'espère que c'est compréhensible.

Btw, le débogueur VS08 montre ce que je veux dire:

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

J'espère que cela clarifie les choses, c'est la petite arborescence qui apparaît dans la petite fenêtre où sont affichées les valeurs actuelles des variables (Autos).

EDIT: Je comprends donc que le pointeur this est nul, je ne comprends tout simplement pas comment il peut être nul. Je vais poster du code:

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();
}

maintenant, dans gameState.h, j'ai une structure similaire (singleton) et une actionHandler * private var, qui est initialisée dans:

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

et aussi une fonction getHandler () qui renvoie le gestionnaire. Tout cela devrait être initialisé dans main.cpp:

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

et ensuite est utilisé:

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

main.cpp est écrit en style .c simple, sans en-tête, alors oui, je suppose que la fonction appelant le gestionnaire est statique ... Cependant, je passe également des appels au pointeur gameState *, qui fonctionne supposément exactement dans le même façon que actionHandler * one .. J'espère que cela le rend plus clair.

Answer 1

Cela ressemble à un cas de fiasco d'ordre d'initialisation statique décrit ici . Vos deux constructeurs d'objets statiques dépendent les uns des autres de manière circulaire, ce qui est très étrange.

Answer 2

Votre ce pointeur est nul.

Quelque chose comme ça se passe:

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

Answer 3

Assurez-vous que l'objet actionHandler que vous appelez act () est initialisé. Il me semble que act () est appelé par un pointeur null .

Answer 4

Vos méthodes actionHandler () ou act () sont-elles statiques?

Parce que si tel est le cas, il est parfaitement normal que votre pointeur soit NULL car les méthodes statiques ne sont pas appelées à partir d'une instance particulière d'un objet.

Par exemple, prenons un objet qui ressemble à ceci:

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

Si un pointeur de fonction sur CThing :: actionHandler () est transmis à une classe tierce pour être averti de quelque chose, cette classe appelle la méthode CThing :: actionHandler () pour vous avertir (en appelant: CThing :: actionHandler (); et non ptrThing- > actionHandler () comme si la méthode actionHandler n'était pas statique), vous ne pourrez pas accéder au pointeur this ni au Variable d'état à partir de actionHandler (ou de tout appel ultérieur effectué à l'intérieur de actionHandler), car il n'y a pas de pointeur, pas d'objet en cours.

C’est pourquoi, lorsque vous utilisez le handler- > state- > getHumanPieces () , cela fonctionne, car vous faites maintenant référence à une instance de la classe CThing (gestionnaire) et non au définition de classe elle-même.

J'espère avoir été suffisamment clair ... Sinon, n'hésitez pas à demander des précisions.