#include <exception>
Typedefs
exception_ptr |
一种类型,描述了一个指向异常的指针 |
terminate_handler |
一种类型,描述了一个适合作为terminate_handler的函数的指针 |
unexperted_handler |
一种类型,描述了一个适合作为unexpected_handler的函数的指针 |
Functions
current_exception |
获得当前异常的指针 |
get_terminate |
获得当前terminate_handler函数 |
get_unexpected |
获得当前unexpected_handler函数 |
make_exception_ptr |
创建一个包含exception副本的exception_ptr对象 |
rethrow_exception |
抛出一个以参数传递的异常 |
set_terminate |
建立一个新的terminate_handler,以便在程序结束时调用 |
set_unexpected |
建立一个新的unexpected_handler,以便在程序遇到未知类型异常时调用 |
terminate |
调用terminate handler |
uncaught_exception |
如果当前正在处理一个已经抛出的异常,那么返回ture |
unexpected |
调用一个未知的处理程序 |
Classes
bad_exception Class |
描述一种异常,该异常可能从unexpected_handler中抛出 |
exception Class |
所有异常类的基类 |
/* ************************************************************************************* */
Typedefs
/* exception_ptr */
typedef unspecified exception_ptr;
说明:
指向exception对象的智能指针类型。这是一种类似shared_ptr的类型:只要还有一个exception_ptr指向exception对象,那么该exception对象就必须保持有效。可以将exception_ptr对象的生命周期延伸到catch语句块外或者不同线程之间。
对于exception_ptr类型,不同的库拥有不同的实现方式,但是其至少需要支持如下几种操作:
- 默认构造函数(接收一个null-pointer)
- 复制构造函数(包括接收一个null-pointer或者nullptr)
- 重载运算符operator==或者operator!=
可以通过以下操作获得exception_ptr对象:current_exception、make_exception_ptr、nested_exception::nested_ptr;通过rethrow_exception重新抛出异常。
// exception_ptr example
#include <iostream> // std::cout
#include <exception> // std::exception_ptr, std::current_exception, std::rethrow_exception
#include <stdexcept> // std::logic_error int main ()
{
std::exception_ptr p;
try
{
throw std::logic_error("some logic_error exception"); // throws
}
catch(const std::exception& e)
{
p = std::current_exception();
std::cout <<"exception caught, but continuing...\n";
} std::cout <<"(after exception)\n"; try
{
std::rethrow_exception(p);
}
catch (const std::exception& e)
{
std::cout <<"exception caught: " << e.what() << '\n';
} return ;
}
/* terminate_handler */
typedef void (*terminate_handler)();
terminate_handler是一个指向void(void)函数的指针,可以用作set_terminate函数的参数和返回值。
/* unexpected_handler */
typedef void (*unexpected_handler)();
unexpected_handler是一个指向void(void)函数的指针,可以用作set_unexpected函数的参数和返回值。
/* ************************************************************************************* */
Classes
/* exception */
class exception {
public:
exception () noexcept;
exception (const exception&) noexcept;
exception& operator= (const exception&) noexcept;
virtual ~exception();
virtual const char* what() const noexcept;
}
说明:
所以标准异常类的基类,因此exception&可以适配所有的异常类型。
直接派生类:
bad_alloc |
allocate memory failed |
bad_cast |
dynamic case failed |
bad_exception |
unexpected handler failed |
bad_function_call |
bad call |
bad_typeid |
typeid of null pointer |
bad_weak_ptr |
bad weak pointer |
ios_base::failure |
base class for stream exceptions |
logic_error |
logic error |
runtime_error |
runtime error |
间接派生类:
通过logic_error派生: |
|
domain_error |
domain error |
future_error |
future error |
invalid_argument |
invalid argument |
length_error |
length error |
out_of_range |
out-of-range |
通过runtime_error派生: |
|
overflow_error |
overflow error |
range_error |
range error |
system_error |
system error |
underflow_error |
system error |
通过bad_alloc派生: |
|
bad_array_new_length |
bad array length |
通过system_error派生: |
|
ios_base::failure |
base class for stream exceptions |
示例代码:
// exception example
#include <iostream> // std::cerr
#include <typeinfo> // operator typeid
#include <exception> // std::exception class Polymorphic
{
virtual void member(){ }
}; int main(){ try
{
Polymorphic * pb = 0;
typeid(*pb); // throws a bad_typeid exception
}
catch(std::exception& e)
{
std::cerr << "exception caught: " << e.what() << '\n';
} return ;
}
/* bad_exception */
class bad_exception : public exception;
说明:
如果bad_exception在函数的throw列表中,那么unexpected将会抛出一个bad_exception来代替terminate函数,因此调用set_unexpected指定的函数后,接着调用bad_exception的catch处理块。
// bad_exception example
#include <iostream> // std::cerr
#include <exception> // std::bad_exception, std::set_unexpected void myunexpected()
{
std::cerr << "unexpected handler called\n";
throw;
} void myfunction() throw(char, std::string, std::bad_exception)
{
throw 100.0; // throws double (not in exception-specification)
} int main(void)
{
std::set_unexpected(myunexpected);
try
{
myfunction();
}
catch(int)
{
std::cerr << "caught int\n";
}
catch(std::bad_exception be)
{
std::cerr << "caught bad_exception: ";
std::cerr << be.what() << "\n";
}
catch(...)
{
std::cerr << "caught some other exception\n";
} return ;
}
上述程序中,语句try{ myfunction(); }后并没有调用terminate()函数,而是先调用set_unexcepted指定的函数myunexpected(),然后调用了
catch(std::bad_exception be)
{
std::cerr << "caught bad_exception: ";
std::cerr << be.what() << "\n";
}
如果throw列表中没有指定std::bad_exception,那么在调用set_unexpected指定的函数后将会调用terminate(),如下所示:
/* nested_exception */
class nested_exception {
public:
nested_exception() noexcept;
nested_exception (const nested_exception&) noexcept = default;
nested_exception& operator= (const nested_exception&) noexcept = default;
virtual ~nested_exception() = default;
[[noreturn]] void rethrow_nested() const;
exception_ptr nested_ptr() const noexcept;
}
说明:
nested exception对象通常可以通过throw_with_nested函数构造,只需要传入outer exception作为参数即可。返回的exception对象拥有与outer exception相同的属性和成员,但是其包含了与nested exception相关的额外信息以及两个用于访问nested exception的成员函数:nested_ptr和rethrow_nested。
// nested_exception example
#include <iostream> // std::cerr
#include <exception> // std::exception, std::throw_with_nested, std::rethrow_if_nested
#include <stdexcept> // std::logic_error // recursively print exception whats:
void print_what(const std::exception& e)
{
std::cerr << e.what() << '\n';
try
{
std::rethrow_if_nested(e);
}
catch(const std::exception& nested)
{
std::cerr << "nested: ";
print_what(nested);
}
} // throws an exception nested in another:
void throw_nested()
{
try
{
throw std::logic_error("first");
}
catch(const std::exception& e)
{
std::throw_with_nested(std::logic_error("second")); /* outer:second; nested:first */
}
} int main()
{
try
{
throw_nested();
}
catch(std::exception& e)
{
print_what(e);
} return ;
} /**
output:
second
nested: first
*/