libstdc++
stdexcept
Go to the documentation of this file.
1 // Standard exception classes -*- C++ -*-
2 
3 // Copyright (C) 2001-2018 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file include/stdexcept
26  * This is a Standard C++ Library header.
27  */
28 
29 //
30 // ISO C++ 19.1 Exception classes
31 //
32 
33 #ifndef _GLIBCXX_STDEXCEPT
34 #define _GLIBCXX_STDEXCEPT 1
35 
36 #pragma GCC system_header
37 
38 #include <exception>
39 #include <string>
40 
41 namespace std _GLIBCXX_VISIBILITY(default)
42 {
43 _GLIBCXX_BEGIN_NAMESPACE_VERSION
44 
45 #if _GLIBCXX_USE_DUAL_ABI
46 #if _GLIBCXX_USE_CXX11_ABI
47  // Emulates an old COW string when the new std::string is in use.
48  struct __cow_string
49  {
50  union {
51  const char* _M_p;
52  char _M_bytes[sizeof(const char*)];
53  };
54 
55  __cow_string();
56  __cow_string(const std::string&);
57  __cow_string(const char*, size_t);
58  __cow_string(const __cow_string&) _GLIBCXX_USE_NOEXCEPT;
59  __cow_string& operator=(const __cow_string&) _GLIBCXX_USE_NOEXCEPT;
60  ~__cow_string();
61 #if __cplusplus >= 201103L
62  __cow_string(__cow_string&&) noexcept;
63  __cow_string& operator=(__cow_string&&) noexcept;
64 #endif
65  };
66 
67  typedef basic_string<char> __sso_string;
68 #else // _GLIBCXX_USE_CXX11_ABI
69  typedef basic_string<char> __cow_string;
70 
71  // Emulates a new SSO string when the old std::string is in use.
72  struct __sso_string
73  {
74  struct __str
75  {
76  const char* _M_p;
77  size_t _M_string_length;
78  char _M_local_buf[16];
79  };
80 
81  union {
82  __str _M_s;
83  char _M_bytes[sizeof(__str)];
84  };
85 
86  __sso_string() _GLIBCXX_USE_NOEXCEPT;
87  __sso_string(const std::string&);
88  __sso_string(const char*, size_t);
89  __sso_string(const __sso_string&);
90  __sso_string& operator=(const __sso_string&);
91  ~__sso_string();
92 #if __cplusplus >= 201103L
93  __sso_string(__sso_string&&) noexcept;
94  __sso_string& operator=(__sso_string&&) noexcept;
95 #endif
96  };
97 #endif // _GLIBCXX_USE_CXX11_ABI
98 #else // _GLIBCXX_USE_DUAL_ABI
99  typedef basic_string<char> __sso_string;
100  typedef basic_string<char> __cow_string;
101 #endif
102 
103  /**
104  * @addtogroup exceptions
105  * @{
106  */
107 
108  /** Logic errors represent problems in the internal logic of a program;
109  * in theory, these are preventable, and even detectable before the
110  * program runs (e.g., violations of class invariants).
111  * @brief One of two subclasses of exception.
112  */
113  class logic_error : public exception
114  {
115  __cow_string _M_msg;
116 
117  public:
118  /** Takes a character string describing the error. */
119  explicit
120  logic_error(const string& __arg) _GLIBCXX_TXN_SAFE;
121 
122 #if __cplusplus >= 201103L
123  explicit
124  logic_error(const char*) _GLIBCXX_TXN_SAFE;
125 #endif
126 
127 #if _GLIBCXX_USE_CXX11_ABI || _GLIBCXX_DEFINE_STDEXCEPT_COPY_OPS
128  logic_error(const logic_error&) _GLIBCXX_USE_NOEXCEPT;
129  logic_error& operator=(const logic_error&) _GLIBCXX_USE_NOEXCEPT;
130 #endif
131 
132  virtual ~logic_error() _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT;
133 
134  /** Returns a C-style character string describing the general cause of
135  * the current error (the same string passed to the ctor). */
136  virtual const char*
137  what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT;
138 
139 # ifdef _GLIBCXX_TM_TS_INTERNAL
140  friend void*
141  ::_txnal_logic_error_get_msg(void* e);
142 # endif
143  };
144 
145  /** Thrown by the library, or by you, to report domain errors (domain in
146  * the mathematical sense). */
147  class domain_error : public logic_error
148  {
149  public:
150  explicit domain_error(const string& __arg) _GLIBCXX_TXN_SAFE;
151 #if __cplusplus >= 201103L
152  explicit domain_error(const char*) _GLIBCXX_TXN_SAFE;
153 #endif
154  virtual ~domain_error() _GLIBCXX_USE_NOEXCEPT;
155  };
156 
157  /** Thrown to report invalid arguments to functions. */
158  class invalid_argument : public logic_error
159  {
160  public:
161  explicit invalid_argument(const string& __arg) _GLIBCXX_TXN_SAFE;
162 #if __cplusplus >= 201103L
163  explicit invalid_argument(const char*) _GLIBCXX_TXN_SAFE;
164 #endif
165  virtual ~invalid_argument() _GLIBCXX_USE_NOEXCEPT;
166  };
167 
168  /** Thrown when an object is constructed that would exceed its maximum
169  * permitted size (e.g., a basic_string instance). */
170  class length_error : public logic_error
171  {
172  public:
173  explicit length_error(const string& __arg) _GLIBCXX_TXN_SAFE;
174 #if __cplusplus >= 201103L
175  explicit length_error(const char*) _GLIBCXX_TXN_SAFE;
176 #endif
177  virtual ~length_error() _GLIBCXX_USE_NOEXCEPT;
178  };
179 
180  /** This represents an argument whose value is not within the expected
181  * range (e.g., boundary checks in basic_string). */
182  class out_of_range : public logic_error
183  {
184  public:
185  explicit out_of_range(const string& __arg) _GLIBCXX_TXN_SAFE;
186 #if __cplusplus >= 201103L
187  explicit out_of_range(const char*) _GLIBCXX_TXN_SAFE;
188 #endif
189  virtual ~out_of_range() _GLIBCXX_USE_NOEXCEPT;
190  };
191 
192  /** Runtime errors represent problems outside the scope of a program;
193  * they cannot be easily predicted and can generally only be caught as
194  * the program executes.
195  * @brief One of two subclasses of exception.
196  */
197  class runtime_error : public exception
198  {
199  __cow_string _M_msg;
200 
201  public:
202  /** Takes a character string describing the error. */
203  explicit
204  runtime_error(const string& __arg) _GLIBCXX_TXN_SAFE;
205 
206 #if __cplusplus >= 201103L
207  explicit
208  runtime_error(const char*) _GLIBCXX_TXN_SAFE;
209 #endif
210 
211 #if _GLIBCXX_USE_CXX11_ABI || _GLIBCXX_DEFINE_STDEXCEPT_COPY_OPS
212  runtime_error(const runtime_error&) _GLIBCXX_USE_NOEXCEPT;
213  runtime_error& operator=(const runtime_error&) _GLIBCXX_USE_NOEXCEPT;
214 #endif
215 
216  virtual ~runtime_error() _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT;
217 
218  /** Returns a C-style character string describing the general cause of
219  * the current error (the same string passed to the ctor). */
220  virtual const char*
221  what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT;
222 
223 # ifdef _GLIBCXX_TM_TS_INTERNAL
224  friend void*
225  ::_txnal_runtime_error_get_msg(void* e);
226 # endif
227  };
228 
229  /** Thrown to indicate range errors in internal computations. */
230  class range_error : public runtime_error
231  {
232  public:
233  explicit range_error(const string& __arg) _GLIBCXX_TXN_SAFE;
234 #if __cplusplus >= 201103L
235  explicit range_error(const char*) _GLIBCXX_TXN_SAFE;
236 #endif
237  virtual ~range_error() _GLIBCXX_USE_NOEXCEPT;
238  };
239 
240  /** Thrown to indicate arithmetic overflow. */
241  class overflow_error : public runtime_error
242  {
243  public:
244  explicit overflow_error(const string& __arg) _GLIBCXX_TXN_SAFE;
245 #if __cplusplus >= 201103L
246  explicit overflow_error(const char*) _GLIBCXX_TXN_SAFE;
247 #endif
248  virtual ~overflow_error() _GLIBCXX_USE_NOEXCEPT;
249  };
250 
251  /** Thrown to indicate arithmetic underflow. */
252  class underflow_error : public runtime_error
253  {
254  public:
255  explicit underflow_error(const string& __arg) _GLIBCXX_TXN_SAFE;
256 #if __cplusplus >= 201103L
257  explicit underflow_error(const char*) _GLIBCXX_TXN_SAFE;
258 #endif
259  virtual ~underflow_error() _GLIBCXX_USE_NOEXCEPT;
260  };
261 
262  // @} group exceptions
263 
264 _GLIBCXX_END_NAMESPACE_VERSION
265 } // namespace
266 
267 #endif /* _GLIBCXX_STDEXCEPT */