Sono incuriosito da come funziona il meccanismo di gestione delle eccezioni C ++. In particolare, dove viene archiviato l'oggetto eccezione e come si propaga attraverso diversi ambiti finché non viene rilevato? È archiviato in un'area globale?
Poiché questo potrebbe essere specifico del compilatore, qualcuno potrebbe spiegarlo nel contesto della suite del compilatore g ++?
Risposte:
Le implementazioni possono differire, ma ci sono alcune idee di base che derivano dai requisiti.
L'oggetto eccezione stesso è un oggetto creato in una funzione, distrutto in un suo chiamante. Quindi, in genere non è possibile creare l'oggetto sullo stack. D'altra parte, molti oggetti eccezione non sono molto grandi. Ergo, si può creare, ad esempio, un buffer da 32 byte e un overflow da accumulare se è effettivamente necessario un oggetto eccezione più grande.
Per quanto riguarda l'effettivo trasferimento del controllo, esistono due strategie. Uno è registrare abbastanza informazioni nello stack stesso per srotolare lo stack. Questo è fondamentalmente un elenco di distruttori da eseguire e gestori di eccezioni che potrebbero catturare l'eccezione. Quando si verifica un'eccezione, eseguire nuovamente lo stack eseguendo quei distruttori fino a trovare un catch corrispondente.
La seconda strategia sposta queste informazioni in tabelle fuori dallo stack. Ora, quando si verifica un'eccezione, lo stack di chiamate viene utilizzato per scoprire quali ambiti vengono inseriti ma non chiusi. Questi vengono quindi cercati nelle tabelle statiche per determinare dove verrà gestita l'eccezione generata e quali distruttori verranno eseguiti nel mezzo. Ciò significa che c'è meno overhead di eccezioni sullo stack; gli indirizzi di ritorno sono comunque necessari. Le tabelle sono dati extra, ma il compilatore può inserirle in un segmento caricato a richiesta del programma.
free()o di un fclose()percorso di codice usato raramente.
Questo è definito in 15.1 Lanciare un'eccezione allo standard.
Il lancio crea un oggetto temporaneo.
Il modo in cui viene allocata la memoria per questo oggetto temporaneo non è specificato.
Dopo la creazione dell'oggetto temporaneo, il controllo viene passato al gestore più vicino nello stack di chiamate. svolgendo la pila tra lancio e punto di presa. Quando lo stack viene svolto, tutte le variabili dello stack vengono distrutte in ordine inverso rispetto alla creazione.
A meno che l'eccezione non venga rilanciata, il temporaneo viene eliminato alla fine del gestore in cui è stato rilevato.
Nota: se prendi per riferimento il riferimento farà riferimento al temporaneo, se prendi per valore l'oggetto temporaneo viene copiato nel valore (e quindi richiede un costruttore di copia).
Consigli di S.Meyers (Cattura per riferimento const).
try
{
// do stuff
}
catch(MyException const& x)
{
}
catch(std::exception const& x)
{
}
Potresti dare un'occhiata qui per una spiegazione dettagliata.
Può anche essere utile dare un'occhiata a un trucco usato in C normale per implementare un tipo di base di gestione delle eccezioni. Ciò implica l'utilizzo di setjmp () e longjmp () nel modo seguente: il primo salva lo stack per contrassegnare il gestore delle eccezioni (come "catch"), mentre il secondo viene utilizzato per "lanciare" un valore. Il valore "generato" è visto come se fosse stato restituito da una funzione chiamata. Il "blocco try" termina quando setjmp () viene chiamato di nuovo o quando la funzione ritorna.
So che questa è una vecchia domanda, ma c'è un'ottima esposizione, che spiega entrambi i metodi utilizzati in ciascuno di gcc e VC qui: http://www.hexblog.com/wp-content/uploads/2012/06/Recon- 2012-Skochinsky-Compiler-Internals.pdf