Distruzione precoce di oggetti in c ++

However, though versions of this text appear all over on the internet my question is not completely answered by this explanation. Though it may be implied, since global variables always seem to be static it would be nice to have a straight out answer.

Se non lo hai creato in modo esplicito, non è necessario distruggerlo esplicitamente. Rimuoviamo solo alcune delle parole dalla tua citazione standard:

Static: Objects declared in global or namespace scope (§6.3.4) ... are created and initialized once (only) and ‘‘live’’ until the program terminates (§15.4.3). Such objects are called static objects.

Quindi, se dichiari un oggetto con scope globali o namespace, è statico e la sua durata è approssimativamente la durata del programma.

Per analogia, considera le variabili locali con ambito normale:

void foo() {
    std::string s;
    // code
}

ora non c'è modo di distruggere s senza uscire dal suo ambito di chiusura. Se lo si distrugge esplicitamente sul posto, il distruttore verrà nuovamente chiamato quando si esce dall'ambito.

Ora, considera che lo scope globale e dello spazio dei nomi sia lo scopo principale del tuo programma. Si entra in questo scope prima di main (che è annidato all'interno dell'ambito globale) e si esce dopo aver lasciato main . Questo ambito di livello superiore dura esattamente quanto il programma e non sei più in grado di distruggere i suoi oggetti prima che tu sia oggetto in qualsiasi altro ambito.

C'è una certa sottigliezza su esattamente quando viene chiamato il costruttore (generalmente prima degli avvii principali, con un fudge per consentire le librerie caricate dinamicamente senza dover parlare di specifiche della piattaforma), quando viene chiamato il distruttore (relativo ai gestori di uscita, diciamo ), e l'ordine relativo di questi per statica diversa (non ben definito, quindi non rendere l'inizializzazione o la distruzione globale dipendente da altri globali).

Naturalmente, se vuoi che l'oggetto sia globale per comodità, puoi comunque scegliere di effettuare chiamate esplicite di setup / cleanup invece di usare il codificatore / l'amministratore per questo.

Questa è una semplice regola C ++: oggetti che sono più complessi di un semplice intero, puntatore, ecc (non di un tipo nativo) con costruttori e distruttori. Quando un'istanza di tale oggetto viene dichiarata per valore all'interno di un ambito, il suo costruttore viene chiamato automaticamente. Quando l'ambito dichiarato è uscito, il distruttore viene chiamato automaticamente. Quindi prendi questo esempio:

// Constructor gets called now, which is before 'main()' 
// enters for a global object like this one.
GraphicsObject graphics;

int main()
{
    // Do stuff with 'graphics'
    // ...

} // When we get here, at the end of main, the destructor of 'graphics' is called.

Non c'è modo di cambiare questo comportamento, ma puoi aggirare il problema se hai bisogno di più controllo sulla durata di un oggetto. Un modo è usare i puntatori. Nell'esempio seguente, userò un puntatore raw per semplicità. non dovresti adottare comunque questo approccio. Preferisci sempre un puntatore intelligente per quello.

// Allocated dynamically with 'new'. Constructor still called here, before 'main()' enters. 
// Destructor will not be called until you 'delete' it yourself.
GraphicsObject * graphics = new GraphicsObject;

int main()
{
    // Do stuff with 'graphics'
    // ...

    // 'graphics' destructor only gets called now because we have explicitly
    // deleted it. If we didn't delete the dynamic object, the destructor
    // would never be called. Not deleting would qualify as a "memory leak", BTW.
    delete graphics;
}

L'uso di un puntatore , invece di una dichiarazione per valore , è il modo predefinito per estendere la durata di un oggetto oltre il suo ambito. Nel tuo caso particolare, tuttavia, sospetto che il problema possa essere risolto in modo più semplice introducendo un metodo cleanup() nel tuo oggetto grafico che chiami alla fine di main() . Assicurati che cleanup() libera tutte le risorse associate ma lascia l'oggetto in uno stato in cui il distruttore può ancora funzionare quando viene chiamato automaticamente alla fine di main() .

Inoltre, sembra che tu stia cercando di implementare il Singleton Pattern , che può essere implementato in diversi modi. Fai una ricerca su internet e potresti trovare altre configurazioni singleton che si adattano meglio alle tue esigenze.