C++: La variable de l'objet ne peut pas être évaluée, mais la variable de la référence au même objet peut?

Question

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

dans l'acte() fonction d'un objet actionHandler je:

state->getHumanPieces(); 

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

handler->state->getHumanPieces(); 

Il fonctionne parfaitement .. Afin de rendre encore plus clair:Ce pointeur 'handler' pointe vers la seule instance de actionHandler existant dans le programme entier (singleton pattern) .. Donc, fondamentalement, quand je lance cette fonction act() depuis mon objet actionHandler, il ne me laisse pas accéder à la variable 'state', MAIS si à partir de cet objet, j'essaie d'accéder à la même variable via un pointeur vers le même objet, c'est ok ?? Je ne comprends pas ce qui se passe .. Je ne suis pas sûr si c'est clair, un peu confus, mais j'espère qu'il 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 

je l'espère, qui le rend plus clair, il est la petite structure d'arbre qui apparaît sur la petite fenêtre où les valeurs actuelles des variables sont représentées (Autos).

EDIT: Je donc obtenir que le ce pointeur est nul, je ne comprends pas comment il peut être nul .. Je vais poster un 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.hi ont une structure similaire (singleton) et un actionHandler * var privé, qui obtient initialisés dans:

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

et également une fonction getHandler() qui renvoie le gestionnaire. Tout cela devrait s'initialisées dans main.cpp:

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

puis est utilisé:

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

main.cpp est écrit dans un style simple .c, sans en-tête, donc oui, je suppose que la La fonction appelant le gestionnaire est statique ... Cependant, je fais aussi des appels au pointeur gameState *, qui fonctionne supposément exactement de la même manière que le gestionnaire actionHandler *. Espérons que cela soit plus clair.

Answer 1

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

Answer 2

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

Answer 3

Votre pointeur this est null.

Quelque chose comme ça se passe:

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

Answer 4

sont vos méthodes actionHandler() ou acte() statique? Parce que si c'est le cas, il est parfaitement normal que ce pointeur this est NULL car les méthodes statiques ne sont pas appelées à partir d'une instance particulière d'un objet.

Par exemple, prendre un objet qui ressemble à ceci:

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

Si un pointeur de fonction CThing :: actionHandler() est passé à une classe tierce partie pour être averti de quelque chose, lorsque cette demande de classe 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 à ce pointeur ni à la variable d'état depuis actionHandler (ou tous les appels ultérieurs faits depuis actionHandler) car il n'y a pas ce pointeur, il n'y a pas d'objet courant. C'est pourquoi, lorsque vous utilisez le handler->state->getHumanPieces(), cela fonctionne, parce que maintenant vous faites référence à une instance de la classe CThing (handler) et non à la définition de la classe elle-même.

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