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 , catch
e 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:
Il gestore terminazioni viene richiamato.
Al termine dell'esecuzione del gestore terminazioni, l'esecuzione continua dopo l'istruzione
__finally
. Tuttavia, la sezione sorvegliata termina (ad esempio, tramite ungoto
corpo sorvegliato o un'istruzionereturn
), 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
, __finally
e __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
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per