Windows与Linux下std::exception的区别

Windows下:

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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114



namespace std {



class exception

{

public:



exception() throw()

: _Data()

{

}



explicit exception(char const* const _Message) throw()

: _Data()

{

__std_exception_data _InitData = { _Message, true };

__std_exception_copy(&_InitData, &_Data);

}



exception(char const* const _Message, int) throw()

: _Data()

{

_Data._What = _Message;

}



exception(exception const& _Other) throw()

: _Data()

{

__std_exception_copy(&_Other._Data, &_Data);

}



exception& operator=(exception const& _Other) throw()

{

if (this == &_Other)

{

return *this;

}



__std_exception_destroy(&_Data);

__std_exception_copy(&_Other._Data, &_Data);

return *this;

}



virtual ~exception() throw()

{

__std_exception_destroy(&_Data);

}



virtual char const* what() const

{

return _Data._What ? _Data._What : "Unknown exception";

}



private:



__std_exception_data _Data;

};

Linux下:

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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

namespace std

{

/**

* @defgroup exceptions Exceptions

* @ingroup diagnostics

*

* Classes and functions for reporting errors via exception classes.

* @{

*/



/**

* @brief Base class for all library exceptions.

*

* This is the base class for all exceptions thrown by the standard

* library, and by certain language expressions. You are free to derive

* your own %exception classes, or use a different hierarchy, or to

* throw non-class data (e.g., fundamental types).

*/

class exception

{

public:

exception() _GLIBCXX_USE_NOEXCEPT { }

virtual ~exception() _GLIBCXX_USE_NOEXCEPT;



/** Returns a C-style character string describing the general cause

* of the current error. */

virtual const char* what() const _GLIBCXX_USE_NOEXCEPT;

};



/** If an %exception is thrown which is not listed in a function's

* %exception specification, one of these may be thrown. */

class bad_exception : public exception

{

public:

bad_exception() _GLIBCXX_USE_NOEXCEPT { }



// This declaration is not useless:

// http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118

virtual ~bad_exception() _GLIBCXX_USE_NOEXCEPT;



// See comment in eh_exception.cc.

virtual const char* what() const _GLIBCXX_USE_NOEXCEPT;

};



/// If you write a replacement %terminate handler, it must be of this type.

typedef void (*terminate_handler) ();



/// If you write a replacement %unexpected handler, it must be of this type.

typedef void (*unexpected_handler) ();



/// Takes a new handler function as an argument, returns the old function.

terminate_handler set_terminate(terminate_handler) _GLIBCXX_USE_NOEXCEPT;



/** The runtime will call this function if %exception handling must be

* abandoned for any reason. It can also be called by the user. */

void terminate() _GLIBCXX_USE_NOEXCEPT __attribute__ ((__noreturn__));



/// Takes a new handler function as an argument, returns the old function.

unexpected_handler set_unexpected(unexpected_handler) _GLIBCXX_USE_NOEXCEPT;



/** The runtime will call this function if an %exception is thrown which

* violates the function's %exception specification. */

void unexpected() __attribute__ ((__noreturn__));



/** [18.6.4]/1: 'Returns true after completing evaluation of a

* throw-expression until either completing initialization of the

* exception-declaration in the matching handler or entering @c unexpected()

* due to the throw; or after entering @c terminate() for any reason

* other than an explicit call to @c terminate(). [Note: This includes

* stack unwinding [15.2]. end note]'

*

* 2: 'When @c uncaught_exception() is true, throwing an

* %exception can result in a call of @c terminate()

* (15.5.1).'

*/

bool uncaught_exception() _GLIBCXX_USE_NOEXCEPT __attribute__ ((__pure__));



// @} group exceptions

} // namespace std

注意这两个类,windows下有带string的构造函数,而linux下是没有的,所以跨平台程序继承这个类的时候需要分开。