c ++: la variabile dell'oggetto non può essere valutata, ma la variabile dal riferimento allo stesso oggetto può?

Question

Ok, questa è veeery strana ... penso. Quello che intendo con il titolo è:

all'interno della funzione act () di un oggetto actionHandler che ho:

state->getHumanPieces();

Il che mi dà una violazione dell'indirizzo di qualche tipo, apparentemente 'questo' non ha una variabile 'stato' inizializzata ... Succede così che questa classe actionHandler abbia una variabile statica, che è un puntatore a un'istanza di se stesso, chiamato "gestore" ... e se lo faccio:

handler->state->getHumanPieces();

Funziona perfettamente .. Per rendere ciò ancora più chiaro:

Quel puntatore 'gestore' punta all'unica istanza di actionHandler esistente nell'intero programma (modello singleton). Quindi fondamentalmente quando eseguo questa funzione act () dal mio oggetto actionHandler, non mi permette di accedere alla variabile 'state', MA se da quell'oggetto, provo ad accedere alla stessa variabile attraverso un puntatore allo stesso oggetto, esso va bene ?? Non capisco cosa stia succedendo .. Non sono sicuro che sia chiaro, probabilmente un po 'confuso, ma spero che sia comprensibile ..

A proposito, il debugger VS08 sta mostrando cosa intendo:

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

Spero che sia più chiaro, è la piccola struttura ad albero che si presenta sulla piccola finestra in cui sono mostrati i valori correnti delle variabili (Auto).

EDIT: Ho così capito che questo puntatore è nullo, non capisco come possa essere nullo .. Pubblicherò del codice:

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

ora, in gameState.h ho una struttura simile (singleton) e un actionHandler * private var, che viene inizializzato in:

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

e anche una funzione getHandler () che restituisce il gestore. Tutto questo dovrebbe essere inizializzato in main.cpp:

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

e quindi viene utilizzato:

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

main.cpp è scritto in semplice stile .c, senza intestazione, quindi sì suppongo che la funzione che chiama il gestore sia statica ... tuttavia, faccio anche chiamate al puntatore gameState *, che presumibilmente funziona esattamente nel allo stesso modo di actionHandler * one .. Spero che questo renda più chiaro.

Answer 1

Sembra un caso di ordine di inizializzazione statico che fiasco ha descritto qui qui . Entrambi i costruttori di oggetti statici dipendono l'uno dall'altro in modo circolare, il che è molto strano.

Answer 2

Il tuo questo puntatore è nullo.

Sta succedendo qualcosa del genere:

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

Answer 3

Assicurati che l'oggetto actionHandler su cui stai chiamando act () sia inizializzato. Mi sembra che act () venga chiamato su un puntatore null .

Answer 4

I tuoi metodi actionHandler () o act () sono statici?

Perché in tal caso, è perfettamente normale che questo puntatore sia NULL perché i metodi statici non vengono chiamati da una particolare istanza di un oggetto.

Ad esempio, prendi un oggetto simile al seguente:

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

Se un puntatore a funzione su CThing :: actionHandler () viene passato a una classe di terze parti per ricevere una notifica di qualcosa, quando questa classe chiama il metodo CThing :: actionHandler () per avvisare l'utente (chiamando: CThing :: actionHandler (); e non ptrThing- > actionHandler () come farebbe se il metodo actionHandler non fosse statico), non potrai accedere a questo puntatore né al variabile di stato dall'interno di actionHandler (o qualsiasi chiamata successiva effettuata dall'interno di actionHandler) perché non esiste questo puntatore, non esiste alcun oggetto corrente.

Questo è il motivo per cui quando si utilizza il handler- > state- > getHumanPieces () funziona, perché ora ci si riferisce a un'istanza della classe CThing (handler) e non al definizione della classe stessa.

Spero di essere stato abbastanza chiaro ... Altrimenti, non esitare a chiedere precisazioni.