Compartilhar via

Funções <exception>

  • Artigo

current_exception

Obtém um ponteiro inteligente para a exceção atual.

exception_ptr current_exception();

Valor de retorno

Um objeto exception_ptr que aponta para a exceção atual.

Comentários

Chame a função current_exception em um bloco catch. Se uma exceção estiver em voo e o bloco catch puder capturar a exceção, a função current_exception retornará um objeto exception_ptr que faz referência à exceção. Caso contrário, a função retornará um objeto exception_ptr nulo.

A função current_exception captura a exceção que está em voo, independentemente de a instrução catch especificar uma instrução exception-declaration.

O destruidor da exceção atual será chamado no fim do bloco catch se você não puder relançar a exceção. No entanto, mesmo que você chame a função current_exception no destruidor, a função retornará um objeto exception_ptr que faz referência à exceção atual.

As chamadas sucessivas à função current_exception retornam objetos exception_ptr que se referem a diferentes cópias da exceção atual. Consequentemente, os objetos são comparados como diferentes, pois se referem a diferentes cópias, mesmo quando as cópias têm o mesmo valor binário.

make_exception_ptr

Cria um objeto exception_ptr que mantém a cópia de uma exceção.

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

Parâmetros

Except
A classe com a exceção a ser copiada. Normalmente, você especifica um objeto de classe de exceção como o argumento para a função make_exception_ptr, embora qualquer objeto de classe possa ser o argumento.

Valor de retorno

Um objeto exception_ptr que aponta para uma cópia da exceção atual de Except.

Comentários

Chamar a função make_exception_ptr é equivalente a lançar uma exceção C++, capturá-la em um bloco catch e chamar a função current_exception para retornar um objeto exception_ptr que faça referência à exceção. A implementação da função make_exception_ptr da Microsoft é mais eficiente do que lançar e depois capturar uma exceção.

Geralmente, um aplicativo não exige a função make_exception_ptr e não recomendamos seu uso.

rethrow_exception

Lança uma exceção passada como um parâmetro.

void rethrow_exception(exception_ptr P);

Parâmetros

P
A exceção capturada para relançamento. Se P for um exception_ptr nulo, a função gerará .std::bad_exception.

Comentários

Depois de armazenar uma exceção capturada em um objeto exception_ptr, o thread primário poderá processar o objeto. Em seu thread primário, chame a função rethrow_exception juntamente com o objeto exception_ptr como seu argumento. A função rethrow_exception extrai a exceção do objeto exception_ptr e a lança no contexto do thread primário.

get_terminate

Obtém a função terminate_handler atual.

terminate_handler get_terminate();

set_terminate

Estabelece um novo terminate_handler a ser chamado na finalização do programa.

terminate_handler set_terminate(terminate_handler fnew) throw();

Parâmetros

fnew
A função a ser chamada no encerramento.

Valor de retorno

O endereço da função anterior que costumava ser chamada no encerramento.

Comentários

A função estabelece um novo terminate_handler como a função * fnew. Portanto, fnew não deve ser um ponteiro nulo. A função retorna o endereço do manipulador de encerramento anterior.

Exemplo

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

Obtém a função unexpected_handler atual.

unexpected_handler get_unexpected();

rethrow_if_nested

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

Comentários

Se não for um tipo de classe polimórfica ou se nested_exception estiver inacessível ou for ambíguo, não haverá efeito. Caso contrário, executa uma conversão dinâmica.

set_unexpected

Estabelece um novo unexpected_handler a ser chamado quando uma exceção inesperada é encontrada.

unexpected_handler set_unexpected(unexpected_handler fnew) throw();

Parâmetros

fnew
A função a ser chamada quando uma exceção inesperada é encontrada.

Valor de retorno

O endereço do unexpected_handler anterior.

Comentários

fnew não deve ser um ponteiro nulo.

O padrão C++ requer que unexpected seja chamado quando uma função lançar uma exceção que não está em sua lista de lançamento. A implementação atual não dá suporte a isso. O exemplo a seguir chama unexpected diretamente, que, em seguida, chama unexpected_handler.

Exemplo

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

{1&gt;terminate&lt;1}

Chama um manipulador de finalização.

void terminate();

Comentários

A função chama um manipulador de encerramento, uma função de tipo void. Se terminate é chamado diretamente pelo programa, o manipulador de encerramento é o mais recentemente definido por uma chamada a set_terminate. Se terminate é chamado por qualquer um dos vários outros motivos durante a avaliação de uma expressão de lançamento, o manipulador de encerramento é aquele em vigor imediatamente depois de avaliar a expressão de lançamento.

Um manipulador de encerramento não pode retornar a seu chamador. Na inicialização do programa, o manipulador de encerramento é uma função que chama abort.

Exemplo

Consulte set_unexpected para obter um exemplo do uso de terminate.

throw_with_nested

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

Comentários

Gera exceção com exceções aninhadas.

uncaught_exception

Retornará true apenas se uma exceção lançada estiver sendo processada no momento.

bool uncaught_exception();

Valor de retorno

Retorna true depois de concluir a avaliação de uma expressão de lançamento e antes de concluir a inicialização da declaração de exceção no manipulador correspondente ou chamar inesperados como resultado da expressão de lançamento. Em particular, uncaught_exception retornará true quando chamado de um destruidor que está sendo invocado durante um desenrolamento de exceção. Em dispositivos, uncaught_exception só tem suporte no Windows CE 5.00 e versões posteriores, incluindo as plataformas Windows Mobile 2005.

Exemplo

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

inesperado

Chama o manipulador inesperado.

void unexpected();

Comentários

O padrão C++ requer que unexpected seja chamado quando uma função lançar uma exceção que não está em sua lista de lançamento. A implementação atual não dá suporte a isso. O exemplo chama unexpected diretamente, que chama o manipulador inesperado.

A função chama um manipulador inesperado, uma função de tipo void. Se unexpected é chamado diretamente pelo programa, o manipulador inesperado é o mais recentemente definido por uma chamada a set_unexpected.

Um manipulador inesperado não pode retornar a seu chamador. Ele pode encerrar a execução:

  • Lançando um objeto de um tipo listado na especificação de exceção ou um objeto de qualquer tipo, se o manipulador inesperado for chamado diretamente pelo programa.

  • Lançando um objeto do tipo bad_exception.

  • Chamando terminate, abort ou exit.

Na inicialização do programa, o manipulador inesperado é uma função que chama terminate.

Exemplo

Consulte set_unexpected para obter um exemplo do uso de unexpected.