Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

try — blocco di gestione delle eccezioni

La parola chiave try introduce un blocco associato a uno o più gestori catch. Un’eccezione generata nel blocco o in una funzione chiamata da esso può trasferire il controllo a un gestore corrispondente. La forma function-try-block fornisce gestori anche per il corpo di una funzione.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

try { /* statements */ }
catch (const Error& e) { /* handle Error */ }
catch (...) { /* handle any other exception */ }

// Function-try-block (constructor form):
// Type::Type() try : member(initializer) { /* body */ }
// catch (...) { /* handle initialization or body failure */ }

try introduce un blocco seguito obbligatoriamente da almeno un gestore catch. Se non si verifica alcuna eccezione, i gestori vengono ignorati. Se il blocco o una funzione chiamata da esso genera un’eccezione, le istruzioni successive sul percorso interrotto non vengono eseguite. Quando un gestore corrispondente di un normale blocco try termina normalmente, l’esecuzione continua dopo l’intero blocco; non riprende dal punto in cui è stata generata l’eccezione.

I gestori vengono esaminati nell’ordine in cui compaiono nel codice sorgente. Inserisci i gestori per le classi derivate prima di quelli per le rispettive classi base. catch (...) corrisponde a qualsiasi eccezione e deve essere l’ultimo gestore. Se nessun gestore corrisponde, la ricerca continua in un blocco try che lo racchiude dinamicamente nello stesso thread. Un’eccezione generata all’interno di un gestore non viene gestita dai gestori fratelli dello stesso blocco.

Durante lo svolgimento dello stack, gli oggetti automatici costruiti negli ambiti abbandonati vengono distrutti nell’ordine inverso a quello del completamento della loro costruzione. Usa RAII per rilasciare le risorse. try non è una protezione generale contro il comportamento indefinito.

Un function-try-block sostituisce il normale corpo di una funzione. Per un costruttore comprende anche l’inizializzazione delle classi base e dei membri, a differenza di un try collocato all’interno del corpo. Nel gestore di un costruttore o distruttore di questo tipo, fare riferimento ai membri non statici o alle classi base di quell’oggetto ha comportamento indefinito; raggiungere la fine del gestore rilancia l’eccezione corrente. Per un costruttore, ciò non recupera un oggetto costruito correttamente.

Questa descrizione riguarda la sintassi disponibile in C++23. Il sito indicato pubblica una bozza di lavoro in evoluzione, non una pubblicazione C++23 definitiva. Un’opzione del compilatore non certifica l’ambiente di esecuzione di produzione.

Esempi

#include <iostream>

struct Error {};

void work() {
    throw Error{};
}

int main() {
    try {
        work();
        std::cout << "unreachable\n";
    } catch (const Error&) {
        std::cout << "caught\n";
    }
    std::cout << "after\n";
}

Risultato

caught
after

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti