come posso controllare se un oggetto esiste in C++

Question

Sto cercando di scrivere una funzione che controllerà se un oggetto esiste:

bool UnloadingBay::isEmpty() { 
    bool isEmpty = true; 
    if(this->unloadingShip != NULL) { 
     isEmpty = false; 
    } 
    return isEmpty; 
} 

io sono abbastanza nuovo per C++ e non è sicuro se il mio background di Java è confusa qualcosa, ma il compilatore restituisce un errore:

UnloadingBay.cpp:36: error: no match for ‘operator!=’ in ‘((UnloadingBay*)this)->UnloadingBay::unloadingShip != 0’ 

Non riesco a capire perché non funziona.

Ecco la dichiarazione per la classe UnloadingBay:

class UnloadingBay { 

    private: 
     Ship unloadingShip; 

    public: 
     UnloadingBay(); 
     ~UnloadingBay(); 

     void unloadContainer(Container container); 
     void loadContainer(Container container); 
     void dockShip(Ship ship); 
     void undockShip(Ship ship); 
     bool isEmpty(); 

}; 

Answer 1

Sembra che potrebbe essere necessario un primer sul concetto di una "variabile" in C++.

In C++, la durata di ogni variabile è legata al suo ambito di copertura. L'esempio più semplice di questo è variabili locali di una funzione:

void foo() // foo scope begins 
{ 
    UnloadingShip anUnloadingShip; // constructed with default constructor 

    // do stuff without fear! 
    anUnloadingShip.Unload(); 
} // // foo scope ends, anything associated with it guaranteed to go away 

Nel codice precedente "anUnloadingShip" viene predefinita costruito quando viene inserita la funzione foo (cioè la sua portata è inserito). Nessun "nuovo" richiesto. Quando l'ambito comprensivo scompare (in questo caso quando foo termina), il distruttore definito dall'utente viene automaticamente chiamato a ripulire UnloadingShip. La memoria associata viene automaticamente ripulita.

Quando l'ambito che comprende è una classe C++ (vale a dire una variabile membro):

class UnloadingBay 
{ 
    int foo; 
    UnloadingShip unloadingShip; 
}; 

la durata è legata alle istanze della classe, in modo che quando la nostra funzione crea un "UnloadingBay"

void bar2() 
{ 
    UnloadingBay aBay; /*no new required, default constructor called, 
         which calls UnloadingShip's constructor for 
         it's member unloadingShip*/ 

    // do stuff! 
} /*destructor fires, which in turn trigger's member's destructors*/ 

i membri di aBay sono costruiti e vivono finché vive "aBay".

Questo è tutto calcolato in tempo di compilazione. Non esiste un conteggio dei riferimenti di runtime che prevenga la distruzione.Nessuna considerazione viene presa per qualcos'altro che potrebbe essere refer to o point to tale variabile. Il compilatore analizza le funzioni che abbiamo scritto per determinare l'ambito e quindi la durata delle variabili. Il compilatore vede dove finisce l'ambito di una variabile e qualsiasi cosa necessaria per ripulire quella variabile verrà inserita in fase di compilazione.

"nuovo", "NULL", (non dimenticare "elimina") in C++ entra in gioco con i puntatori. I puntatori sono un tipo di variabile che contiene un indirizzo di memoria di qualche oggetto. I programmatori usano il valore "NULL" per indicare che un puntatore non ha un indirizzo (cioè non punta a nulla). Se non stai usando i puntatori, non devi pensare a NULL.

Fino a quando non hai imparato come le variabili in C++ vanno dentro e fuori dall'ambito, evitare i puntatori. È un altro argomento interamente.

Buona fortuna!

Answer 2

Sto assumendo unloadingShip è un oggetto e non un puntatore in modo che il valore potrebbe non essere NULL.

ie.

SomeClass unloadingShip

contro

SomeClass * unloadingShip

Answer 3

Beh, non c'è bisogno di scrivere codice così tanto per verificare se un puntatore è NULL o meno. Il metodo potrebbe essere molto più semplice:

bool UnloadingBay::isEmpty() const { 
    return unloadingShip == NULL; 
} 

Inoltre, deve essere contrassegnato come "const", perché non modifica lo stato dell'oggetto e può essere chiamato su casi costanti pure.

Nel tuo caso, "unloadingShip" è un oggetto di classe "UnloadingShip" che non è allocato dinamicamente (tranne quando l'intera classe "UnloadingBay" è allocata dinamicamente). Quindi, verificare se è uguale a NULL non ha senso perché non è un puntatore.

Answer 4

Per il controllo, se è presente un oggetto, si può considerare l'idea in questo modo:

creare un puntatore all'oggetto:

someClass *myObj = NULL // Make it null 

e ora in cui si passa questo puntatore, è possibile controllare:

if(!myObj) // if its set null, it wont pass this condition 
    myObj = new someClass(); 

e quindi nel caso in cui si desidera eliminare, si può fare questo:

if(myobj) 
{ 
    delete myObj; 
    myObj = NULL; 
} 

in questo modo, è possibile avere un buon controllo sul controllo dell'esistenza dell'oggetto, prima di eliminarlo o prima di crearne uno nuovo.

Spero che questo aiuti!