1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
|
tt(Std::promise's) member tt(set_exception) does not expect an
tt(std::exception) argument, but an object of the class
hi(exception_ptr)tt(std::exception_ptr). In this section we take a closer look
at the class tt(exception_ptr).
Before using the class tt(exception_ptr) the tthi(future) header file
must be included.
The class an tt(exception_ptr's) default constructor initializes it to a
null-pointer. In the following code snippet the variable tt(isNull) is set to
true:
verb( std::exception_ptr obj;
bool isNull = obj == nullptr && obj == 0;
)
The class tt(exception_ptr) provides copy and move constructors as well as
copy and move assignment operators.
Two tt(exception_ptr) objects can be compared for equality. They are equal
if they refer to the same exception. Move assignment transfers the exception
referred to by the right-hand side operand to the left-hand side operand, and
turns the right-hand side operand into a null pointer.
There is no published method directly retrieving the exception to which an
tt(exception_ptr) object refers. However, there are some free functions
constructing or handling tt(exception_ptr) objects:
itemization(
ithtq(current_exception)
(std::exception_ptr std::current_exception() noexcept)
(An tt(exception_ptr) object is returned referring to the currently
handled exception (or a copy of the currently handled exception, or a
default constructed tt(exception_ptr) object if no current exception
is available). This function can also be called when a default
exception catcher is used. E.g., assuming that tt(obj) refers to an
available tt(std::promise) object, then the following code snippet
assigns the exception caught by default catch clause to tt(obj):
verb(
...
catch (...)
{
obj.set_exception(std::current_exception());
}
)
The exception referred to by tt(current_exception) does not have to
be an object of the class tt(std::exception). Any type of object or
value thrown as an exception is retrieved as an tt(exception_ptr) by
tt(current_exception). The exception referred to by an
tt(exception_ptr) object remains valid for at least as long as there
exists an tt(exception_ptr) object that refers to it. Calling
tt(current_exception) twice in a row then the two returned
tt(exception_ptr) objects may or may not refer to the same exception
object.)
ithtq(make_exception_ptr)(std::exception_ptr make_exception_ptr(Type
value) noexcept)
(This function template constructs an tt(exception_ptr) from a value of
any type which is passed as its argument. tt(Type) does not
necessarily have to be an tt(std::exception). The constructed
tt(exception_ptr) could, e.g., be assigned to a tt(std::promise). When
the promise's future's tt(get) member is subsequently called (possibly
from within another thread) the exception will be thrown. Here are
some examples, showing how values of different types can be passed as
arguments to tt(make_exception_ptr), and showing how the eventually
constructed tt(exception_ptr) is assigned to the tt(obj), which is
assumed to be of a tt(std::promise) type:
verb(
auto ptr = make_exception_ptr(exception());
ptr = make_exception(string("hello world"));
ptr = make_exception(12));
obj.set_exception(make_exception_ptr(ptr);
)
)
ithtq(rethrow_exception)(void std::rethrow_exception(exception_ptr obj))
(The exception to which tt(obj) refers is thrown. Note: tt(obj)
cannot be a tt(nullptr).)
)
|
