Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

noexcept — specifica delle eccezioni e operatore

noexcept dichiara che un’eccezione non può uscire da una funzione oppure verifica in fase di compilazione se un’espressione può potenzialmente lanciare eccezioni. I due usi si combinano nella specifica condizionale noexcept(noexcept(expression)).

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

Sintassi

void f() noexcept;
void g() noexcept(constant_expression);
noexcept(expression)
// Conditional specification:
template<class F>
void invoke(F f) noexcept(noexcept(f())) { f(); }

Dopo un dichiaratore di funzione, noexcept ha lo stesso significato di noexcept(true): la specifica impedisce alle eccezioni di propagarsi all’esterno della funzione. noexcept(false) consente la propagazione delle eccezioni, ma non richiede che ne venga lanciata una. La condizione deve essere un’espressione costante di tipo bool ottenuta mediante conversione contestuale. Non sono ammesse conversioni di restringimento.

Se un’eccezione tenta di propagarsi all’esterno di una funzione con tale specifica, viene invocato std::terminate; un catch esterno non può intercettarla. Non si deve presumere che lo stack venga svolto completamente. La funzione può tuttavia lanciare un’eccezione e gestirla al proprio interno.

L’operatore noexcept(expression) produce un valore costante di tipo bool senza eseguire il proprio operando. Il risultato indica se l’intera espressione può potenzialmente lanciare eccezioni secondo le regole del linguaggio, non se una particolare esecuzione ne lancerà una. Il solo corpo vuoto di una funzione ordinaria non garantisce true.

In noexcept(noexcept(f())), il noexcept esterno è una specifica e quello interno è l’operatore che ne determina la condizione. L’esempio mostra anche che verificare safe() non incrementa calls, mentre chiamarla davvero tramite invoke lo fa.

L’esempio è destinato alla compilazione in C++23. La fonte fornita è una bozza di lavoro in evoluzione, non una pubblicazione definitiva di C++23. Il codice mostrato è stato eseguito senza modifiche in un ambiente isolato e il suo output standard ha coinciso esattamente con quello indicato. L’uso in fase di esecuzione in produzione non è attestato.

Esempi

#include <iostream>

int calls = 0;

void safe() noexcept { ++calls; }
void ordinary() {}

template<class F>
void invoke(F f) noexcept(noexcept(f())) {
    f();
}

int main() {
    static_assert(noexcept(safe()));
    static_assert(!noexcept(ordinary()));
    static_assert(noexcept(invoke(safe)));
    static_assert(!noexcept(invoke(ordinary)));

    const bool checked = noexcept(safe());
    std::cout << std::boolalpha << checked << ' ' << calls << '\n';
    invoke(safe);
    std::cout << calls << '\n';
}

Risultato

true 0
1

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