try-finally - istruzione

L'istruzione try-finally è un'estensione specifica di Microsoft che supporta la gestione strutturata delle eccezioni nei linguaggi C e C++.

Sintassi

La sintassi seguente descrive l'istruzione try-finally :

    // . . .
    __try {
        // guarded code
    }
    __finally {
        // termination code
    }
    // . . .

Grammatica

try-finally-statement:
 __try compound-statement __finally compound-statement

L'istruzione try-finally è un'estensione Microsoft per i linguaggi C e C++ che consentono alle applicazioni di destinazione di garantire l'esecuzione del codice di pulizia quando l'esecuzione di un blocco di codice viene interrotta. La pulizia è costituita da attività quali la deallocazione della memoria, la chiusura dei file e il rilascio di handle di file. L'istruzione try-finally è particolarmente utile per le routine che presentano vari punti in cui viene eseguito un controllo per verificare la presenza di un errore che potrebbe causare la restituzione prematura dalla routine.

Per informazioni correlate e un esempio di codice, vedere try-except Istruzione. Per altre informazioni sulla gestione delle eccezioni strutturata in generale, vedere Gestione delle eccezioni strutturate. Per altre informazioni sulla gestione delle eccezioni nelle applicazioni gestite con C++/CLI, vedere Gestione delle eccezioni in /clr.

Nota

La gestione eccezioni strutturata funziona con i file Win32 per i file di origine C++ e C. Tuttavia, non è progettato in particolare per C++. È possibile garantire maggiore portabilità del codice tramite la gestione delle eccezioni C++. Inoltre, la gestione eccezioni C++ è più flessibile, in quanto può gestire le eccezioni di qualsiasi tipo. Per i programmi C++, è consigliabile usare il meccanismo di gestione delle eccezioni C++ (istruzioni , catche throw ).try

L'istruzione composta dopo la clausola __try è la sezione protetta. L'istruzione composta dopo la clausola __finally è il gestore terminazioni. Il gestore specifica un set di azioni eseguite quando la sezione sorvegliata viene chiusa, indipendentemente dal fatto che esce dalla sezione sorvegliata da un'eccezione (terminazione anomala) o da una terminazione standard (terminazione normale).

Il controllo raggiunge un'istruzione __try tramite l'esecuzione sequenziale semplice (passaggio). Quando il controllo entra in __try, il gestore associato diventa attivo. Se il flusso di controllo raggiunge la fine del blocco try, l'esecuzione continua come segue:

1. Il gestore terminazioni viene richiamato.

2. Al termine dell'esecuzione del gestore terminazioni, l'esecuzione continua dopo l'istruzione __finally. Tuttavia, la sezione sorvegliata termina (ad esempio, tramite un goto corpo sorvegliato o un'istruzione return ), il gestore di terminazione viene eseguito prima che il flusso di controllo si muova fuori dalla sezione sorvegliata.

   Un'istruzione __finally non blocca la ricerca di un gestore eccezioni appropriato.

Se si verifica un'eccezione nel __try blocco, il sistema operativo deve trovare un gestore per l'eccezione oppure il programma avrà esito negativo. Se viene trovato un gestore, tutti i __finally blocchi vengono eseguiti e l'esecuzione riprende nel gestore.

Si supponga ad esempio che una serie di chiamate di funzione colleghi la funzione A alla funzione D, come illustrato di seguito. Ogni funzione dispone di un gestore di terminazione. Se un'eccezione viene generata nella funzione D e gestita in A, i gestori di terminazione, man mano che il sistema rimuove lo stack, vengono chiamati nell'ordine seguente: D, C, B.

Il diagramma inizia con la funzione A, che chiama la funzione B, che chiama la funzione C, che chiama la funzione D. Funzione D genera un'eccezione. I gestori di terminazione vengono quindi chiamati in questo ordine: gestore di terminazione D, quindi C, B e quindi A gestisce l'eccezione.

Ordine di esecuzione del gestore di terminazione

Nota

Il comportamento di try-finally è diverso da altri linguaggi che supportano l'uso di finally, ad esempio C#. Un singolo __try può avere uno dei due, ma non entrambi, di __finally e __except. Se entrambi devono essere utilizzati insieme, un'istruzione try-except deve racchiudere l'istruzione try-finally interna. Sono diverse anche le regole che specificano quando viene eseguito ciascun blocco.

Per la compatibilità con le versioni precedenti, , e sono sinonimi per __try, __finallye __leave a meno che non sia specificata l'opzione /Za del compilatore (Disabilita estensioni del linguaggio)._leave_finally_try

La parola chiave __leave

La __leave parola chiave è valida solo all'interno della sezione sorvegliata di un'istruzione try-finally e il relativo effetto consiste nel passare alla fine della sezione sorvegliata. L'esecuzione continua con la prima istruzione nel gestore di terminazione.

Un'istruzione goto può anche uscire dalla sezione sorvegliata, ma riduce le prestazioni perché richiama la rimozione dello stack. L'istruzione __leave è più efficiente perché non causa la rimozione dello stack.

Terminazione anomala

L'uscita da un'istruzione try-finally che usa la funzione di runtime longjmp è considerata una terminazione anomala. Non è legale passare a una __try dichiarazione, ma è legale saltare fuori da uno. Devono essere eseguite tutte le __finally istruzioni attive tra il punto di partenza (terminazione normale del __try blocco) e la destinazione (il __except blocco che gestisce l'eccezione). Si chiama rimozione locale.

Se un __try blocco viene terminato prematuramente per qualsiasi motivo, incluso un salto dal blocco, il sistema esegue il blocco associato __finally come parte del processo di rimozione dello stack. In questi casi, la AbnormalTermination funzione restituisce true se viene chiamato dall'interno del __finally blocco; in caso contrario, restituisce false.

Il gestore di terminazione non viene chiamato se un processo viene terminato al centro dell'esecuzione di un'istruzione try-finally .

END Specifico di Microsoft

Vedi anche

Scrittura di un gestore di terminazione
Structured Exception Handling (C/C++)
Parole chiave
Sintassi del gestore di terminazione