<exception> -Funktionen

current_exception

Erhält einen intelligenten Zeiger auf die aktuelle Ausnahme.

exception_ptr current_exception();

Rückgabewert

Ein exception_ptr-Objekt, das auf die aktuelle Ausnahme zeigt.

Bemerkungen

Rufen Sie die current_exception-Funktion in einem catch-Block auf. Wenn eine Ausnahme aktiv ist und die Ausnahme vom catch-Block nicht abgefangen werden kann, gibt die current_exception-Funktion ein exception_ptr-Objekt zurück, das auf die Ausnahme verweist. Andernfalls gibt die Funktion ein NULL-exception_ptr-Objekt zurück.

Die current_exception-Funktion erfasst die Ausnahme, die aktiv ist, unabhängig davon, ob die catch-Anweisung eine exception-declaration-Anweisung angibt.

Der Destruktor für die aktuelle Ausnahme wird am Ende des catch-Blocks aufgerufen, wenn die Ausnahme nicht erneut ausgelöst wird. Auch wenn Sie die current_exception-Funktion im Destruktor aufrufen, gibt die Funktion ein exception_ptr-Objekt zurück, das auf die aktuelle Ausnahme verweist.

Aufeinander folgende Aufrufe der current_exception-Funktion geben exception_ptr-Objekte zurück, die sich auf unterschiedliche Kopien der aktuellen Ausnahme beziehen. Folglich sind die Objekte bei einem Vergleich ungleich, da sie auf unterschiedliche Kopien verweisen, auch wenn die Kopien den gleichen Binärwert aufweisen.

make_exception_ptr

Erstellt ein exception_ptr-Objekt, das eine Kopie einer Ausnahme enthält.

template <class E>
    exception_ptr make_exception_ptr(E Except);

Parameter

Außer
Die Klasse mit der zu kopierenden Ausnahme. Normalerweise geben Sie ein exception class-Objekt als Argument für die make_exception_ptr-Funktion an, obwohl jedes Klassenobjekt als Argument zulässig ist.

Rückgabewert

Ein exception_ptr Objekt, das auf eine Kopie der aktuellen Ausnahme verweist, für "Außer".

Bemerkungen

Das Aufrufen der make_exception_ptr-Funktion ist gleichbedeutend mit dem Auslösen einer C++-Ausnahme, die in einem catch-Block abgefangen wird, und dem anschließenden Aufrufen der current_exception-Funktion, um ein exception_ptr-Objekt zurückzugeben, das auf die Ausnahme verwiest. Die Microsoft-Implementierung der make_exception_ptr-Funktion ist effizienter als das Auslösen und anschließende Abfangen einer Ausnahme.

Eine Anwendung erfordert in der Regel nicht die make_exception_ptr -Funktion, und es wird von ihrer Verwendung abgeraten.

rethrow_exception

Löst eine Ausnahme aus, die als Parameter übergeben wird.

void rethrow_exception(exception_ptr P);

Parameter

P
Die erneut auszulösende abgefangene Ausnahme. Wenn P null exception_ptr ist, löst die Funktion std::bad_exception aus.

Bemerkungen

Nachdem Sie eine abgefangene Ausnahme in einem exception_ptr-Objekt gespeichert haben, kann der primäre Thread das Objekt verarbeiten. Rufen Sie in Ihrem primären Thread die rethrow_exception-Funktion zusammen mit dem exception_ptr-Objekt als Argument auf. Die rethrow_exception-Funktion extrahiert die Ausnahme vom exception_ptr-Objekt und löst die Ausnahme anschließend im Kontext des primären Threads aus.

get_terminate

Ruft die aktuelle terminate_handler-Funktion ab.

terminate_handler get_terminate();

set_terminate

Richtet ein neues terminate_handler-Element ein, das bei Beendigung des Programms aufgerufen wird.

terminate_handler set_terminate(terminate_handler fnew) throw();

Parameter

fnew
Die bei Beendigung aufzurufende Funktion.

Rückgabewert

Die Adresse der vorherigen Funktion, die von bei Beendigung aufgerufen wurde.

Bemerkungen

Die Funktion erstellt eine neue terminate_handler als Funktion * fnew. Daher darf fnew kein Nullzeiger sein. Die Funktion gibt die Adresse des vorherigen terminate-Handlers zurück.

Beispiel

// 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

Ruft die aktuelle unexpected_handler-Funktion ab.

unexpected_handler get_unexpected();

rethrow_if_nested

template <class E>
    void rethrow_if_nested(const E& e);

Bemerkungen

Wenn kein polymorpher Klassentyp oder nested_exception nicht auf einen nicht zugänglichen oder mehrdeutigen Klassentyp zugegriffen werden kann, gibt es keine Auswirkung. Andernfalls wird eine dynamische Umwandlung ausgeführt.

set_unexpected

Richtet ein neues unexpected_handler ein, das bei einer unerwarteten Ausnahme auftritt.

unexpected_handler set_unexpected(unexpected_handler fnew) throw();

Parameter

fnew
Die Funktion, die bei einer unerwarteten Ausnahme aufgerufen wird.

Rückgabewert

Die Adresse des vorherigen unexpected_handler-Elements.

Bemerkungen

fnew darf kein Nullzeiger sein.

Für den C++-Standard ist es erforderlich, dass unexpected aufgerufen wird, wenn eine Funktion eine Ausnahme auslöst, die nicht auf der Auslöseliste aufgeführt wird. Die augenblickliche Implementierung unterstützt das nicht. Im folgenden Beispiel ruft unexpected direkt auf, woraufhin unexpected_handler aufgerufen wird.

Beispiel

// 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
}

beenden

Ruft einen terminate-Handler auf.

void terminate();

Bemerkungen

Die Funktion ruft einen terminate-Handler auf, eine Funktion vom Typ void. Wenn terminate der Handler direkt vom Programm aufgerufen wird, ist der Handler für die Beendigung der Letzten durch einen Aufruf von set_terminate festgelegt. Wenn terminate während der Auswertung eines Wurfausdrucks mehrere andere Gründe aufgerufen werden, ist der Endhandler unmittelbar nach der Auswertung des Auslösenausdrucks der Handler wirksam.

Ein terminate-Handler kehrt möglicherweise nicht zum Aufrufer zurück. Beim Programmstart ist der Endhandler eine Funktion, die aufruft abort.

Beispiel

Ein Beispiel zur Verwendung von terminate finden Sie unter set_unexpected.

throw_with_nested

template <class T> [[noreturn]]
    void throw_with_nested(T&& t);

Bemerkungen

Löst Ausnahme mit geschachtelten Ausnahmen aus.

uncaught_exception

Gibt nur dann true zurück, wenn augenblicklich eine Ausnahme verarbeitet wird.

bool uncaught_exception();

Rückgabewert

Gibt true nach Abschluss der Auswertung eines Throw-Ausdrucks und vor Abschluss der Initialisierung der Ausnahmedeklaration an den entsprechenden Handler oder durch Aufruf von unexpected als Ergebnis des Throw-Ausdrucks zurück. Insbesondere gibt uncaught_exceptiontrue zurück, wenn die Funktion von einem Destruktor aufgerufen wird, der während des Entladevorgangs für die Ausnahme aufgerufen wird. Auf Geräten wird uncaught_exception nur auf Windows CE 5.00 und höheren Versionen, darunter Windows Mobile 2005-Plattformen unterstützt.

Beispiel

// 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

unerwartet

Ruft den unerwarteten Handler auf.

void unexpected();

Bemerkungen

Für den C++-Standard ist es erforderlich, dass unexpected aufgerufen wird, wenn eine Funktion eine Ausnahme auslöst, die nicht auf der Auslöseliste aufgeführt wird. Die augenblickliche Implementierung unterstützt das nicht. Das Beispiel ruft unexpected direkt auf, wodurch der unerwartete Handler aufgerufen wird.

Die Funktion ruft einen unerwarteten Handler auf, eine Funktion vom Typ void. Wenn unexpected direkt vom Programm aufgerufen wird, ist der unerwartete Handler durch einen Aufruf von set_unexpected der zuletzt festgelegte Handler.

Ein unerwarteter Handler kehrt möglicherweise nicht zum Aufrufer zurück. Die Ausführung kann hierdurch beendet werden:

  • Auslösen eines Objekts eines Typs, das in der Ausnahmespezifikation gelistet ist oder eines Objekts jeglichen Typs, wenn der unerwartete Handler direkt durch das Programm aufgerufen wird.

  • Auslösen eines Objekt des Typs bad_exception.

  • Anruf beendenabort oder exit.

Bei Programmstart ist der unerwartete Handler eine Funktion, die erminate aufruft.

Beispiel

Ein Beispiel zur Verwendung von unexpected finden Sie unter set_unexpected.