Condividi tramite

<exception> funzioni

  • Articolo

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.