<exception> funzioni
current_exception
Ottiene un puntatore intelligente all'eccezione corrente.
exception_ptr current_exception();
Valore restituito
Oggetto exception_ptr che punta all'eccezione corrente.
Osservazioni:
Chiama la funzione current_exception in un blocco catch. Se è in corso un'eccezione e il blocco catch riesce a rilevarla, la funzione current_exception restituisce un oggetto exception_ptr che fa riferimento a tale eccezione. In caso contrario, la funzione restituisce un oggetto exception_ptr Null.
La funzione current_exception acquisisce l'eccezione in corso, indipendentemente dal fatto che l'istruzione catch specifichi o meno un'istruzione exception-declaration.
Il distruttore dell'eccezione corrente viene chiamato alla fine del blocco catch se non si rigenera l'eccezione. Tuttavia, anche se si chiama la funzione current_exception nel distruttore, la funzione restituisce un oggetto exception_ptr che fa riferimento all'eccezione corrente.
Le chiamate successive alla funzione current_exception restituiscono oggetti exception_ptr che fanno riferimento a copie diverse dell'eccezione corrente. Di conseguenza, gli oggetti vengono considerati diversi perché fanno riferimento a copie diverse, anche se le copie presentano lo stesso valore binario.
make_exception_ptr
Crea un oggetto exception_ptr contenente la copia di un'eccezione.
template <class E>
exception_ptr make_exception_ptr(E Except);
Parametri
Except
Classe con l'eccezione da copiare. In genere, è possibile specificare un oggetto della classe exceptionmake_exception_ptr come argomento della funzione , anche l'argomento può essere costituito da qualsiasi oggetto classe.
Valore restituito
Oggetto exception_ptr che punta a una copia dell'eccezione corrente per Except.
Osservazioni:
Chiamare la funzione make_exception_ptr equivale a generare una eccezione C++, rilevarla in un blocco catch, quindi chiamare la funzione current_exception per restituire un oggetto exception_ptr che fa riferimento a tale eccezione. L'implementazione Microsoft della funzione make_exception_ptr è più efficiente della generazione e del rilevamento di un'eccezione.
In genere un'applicazione non richiede la funzione make_exception_ptr e se ne sconsiglia l'utilizzo.
rethrow_exception
Genera un'eccezione passata come parametro.
void rethrow_exception(exception_ptr P);
Parametri
P
Eccezione rilevata da generare nuovamente. Se P è un exception_ptr Null, la funzione genera std::bad_exception.
Osservazioni:
Dopo aver archiviato un'eccezione intercettata in un oggetto exception_ptr, il thread principale può elaborare l'oggetto. Nel thread principale, chiamare la funzione rethrow_exception insieme all'oggetto exception_ptr come suo argomento. La funzione rethrow_exception estrae l'eccezione dall'oggetto exception_ptr, quindi genera l'eccezione nel contesto del thread principale.
get_terminate
Ottiene la funzione terminate_handler corrente.
terminate_handler get_terminate();
set_terminate
Crea un nuovo terminate_handler da chiamare al termine del programma.
terminate_handler set_terminate(terminate_handler fnew) throw();
Parametri
fnew
Funzione da chiamare alla chiusura.
Valore restituito
Indirizzo della funzione precedente chiamata alla chiusura.
Osservazioni:
La funzione stabilisce un nuovo terminate_handler come funzione * fnew. Pertanto, fnew non deve essere un puntatore Null. La funzione restituisce l'indirizzo del gestore di terminazione precedente.
Esempio
// exception_set_terminate.cpp
// compile with: /EHsc
#include <exception>
#include <iostream>
using namespace std;
void termfunction()
{
cout << "My terminate function called." << endl;
abort();
}
int main()
{
terminate_handler oldHandler = set_terminate(termfunction);
// Throwing an unhandled exception would also terminate the program
// or we could explicitly call terminate();
//throw bad_alloc();
terminate();
}
get_unexpected
Ottiene la funzione unexpected_handler corrente.
unexpected_handler get_unexpected();
rethrow_if_nested
template <class E>
void rethrow_if_nested(const E& e);
Osservazioni:
Se non è un tipo di classe polimorfica o se nested_exception è inaccessibile o ambiguo, non vi è alcun effetto. In caso contrario, esegue un cast dinamico.
set_unexpected
Stabilisce un nuovo unexpected_handler quando viene rilevata un'eccezione imprevista.
unexpected_handler set_unexpected(unexpected_handler fnew) throw();
Parametri
fnew
Funzione da chiamare quando viene rilevata un'eccezione imprevista.
Valore restituito
Indirizzo dell'oggetto unexpected_handler precedente.
Osservazioni:
fnew non deve essere un puntatore Null.
Lo standard C++ richiede che venga chiamato unexpected quando una funzione genera un'eccezione che non si trova nell'elenco throw. L'implementazione corrente non supporta questa condizione. Nell'esempio seguente viene chiamato direttamente unexpected, che a sua volta chiama unexpected_handler.
Esempio
// exception_set_unexpected.cpp
// compile with: /EHsc
#include <exception>
#include <iostream>
using namespace std;
void uefunction()
{
cout << "My unhandled exception function called." << endl;
terminate(); // this is what unexpected() calls by default
}
int main()
{
unexpected_handler oldHandler = set_unexpected(uefunction);
unexpected(); // library function to force calling the
// current unexpected handler
}
terminate
Chiama un gestore di terminazione.
void terminate();
Osservazioni:
La funzione chiama un gestore di terminazione, una funzione di tipo void. Se terminate viene chiamato direttamente dal programma, il gestore terminate è quello impostato più di recente da una chiamata a set_terminate. Se terminate viene chiamato per uno qualsiasi di altri motivi durante la valutazione di un'espressione throw, il gestore di terminazione è quello in vigore immediatamente dopo la valutazione dell'espressione throw.
Un gestore di terminazione potrebbe non restituire risultati al relativo chiamante. All'avvio del programma, il gestore terminate è una funzione che chiama abort.
Esempio
Per un esempio dell'utilizzo di terminate, vedere set_unexpected.
throw_with_nested
template <class T> [[noreturn]]
void throw_with_nested(T&& t);
Osservazioni:
Genera un'eccezione con eccezioni annidate.
uncaught_exception
Restituisce true solo se un'eccezione generata è in corso di elaborazione.
bool uncaught_exception();
Valore restituito
Restituisce true dopo aver completato la valutazione di un'espressione throw e prima di aver completato l'inizializzazione della dichiarazione di eccezione del gestore corrispondente o aver chiamato la funzione unexpected come risultato dell'espressione throw. In particolare uncaught_exception restituirà true in seguito alla chiamata da un distruttore richiamato durante la rimozione di un'eccezione. Nei dispositivi la funzione uncaught_exception è supportata solo in Windows CE 5.00 e versioni successive, comprese le piattaforme Windows Mobile 2005.
Esempio
// exception_uncaught_exception.cpp
// compile with: /EHsc
#include <exception>
#include <iostream>
#include <string>
class Test
{
public:
Test( std::string msg ) : m_msg( msg )
{
std::cout << "In Test::Test(\"" << m_msg << "\")" << std::endl;
}
~Test( )
{
std::cout << "In Test::~Test(\"" << m_msg << "\")" << std::endl
<< " std::uncaught_exception( ) = "
<< std::uncaught_exception( )
<< std::endl;
}
private:
std::string m_msg;
};
// uncaught_exception will be true in the destructor
// for the object created inside the try block because
// the destructor is being called as part of the unwind.
int main( void )
{
Test t1( "outside try block" );
try
{
Test t2( "inside try block" );
throw 1;
}
catch (...) {
}
}
In Test::Test("outside try block")
In Test::Test("inside try block")
In Test::~Test("inside try block")
std::uncaught_exception( ) = 1
In Test::~Test("outside try block")
std::uncaught_exception( ) = 0
imprevisto
Chiama il gestore imprevisto.
void unexpected();
Osservazioni:
Lo standard C++ richiede che venga chiamato unexpected quando una funzione genera un'eccezione che non si trova nell'elenco throw. L'implementazione corrente non supporta questa condizione. Nell'esempio la funzione unexpected viene chiamata direttamente e a sua volta chiama il gestore imprevisto.
La funzione chiama un gestore imprevisto, una funzione di tipo void. Se la funzione unexpected viene chiamata direttamente dal programma, il gestore imprevisto è quello impostato più di recente da una chiamata a set_unexpected.
Un gestore imprevisto potrebbe non restituire risultati al relativo chiamante. Potrebbe terminare l'esecuzione in uno dei modi seguenti:
Generando un oggetto di un tipo elencato nella specifica di eccezione o un oggetto di qualsiasi tipo, se il gestore imprevisto viene chiamato direttamente dal programma.
Generando un oggetto di tipo bad_exception.
Chiamata di terminate o
exitabort.
All'avvio del programma, il gestore imprevisto è una funzione che chiama terminate.
Esempio
Per un esempio dell'utilizzo di unexpected, vedere set_unexpected.