______________________________________________________________________
18 Language support library [lib.language.support]
______________________________________________________________________
1 This clause describes the function signatures that are called implic
itly, and the types of objects generated implicitly, during the execu
tion of some C++ programs. It also describes the headers that declare
these function signatures and define any related types.
2 The following subclauses describe common type definitions used
throughout the library, characteristics of the predefined types, func
tions supporting start and termination of a C++ program, support for
dynamic memory management, support for dynamic type identification,
support for exception processing, and other runtime support, as summa
rized in Table 1:
Table 1--Language support library summary
+--------------------------------------------------------------+
| Subclause Header(s) |
+--------------------------------------------------------------+
|_lib.support.types_ Types <cstddef> |
+--------------------------------------------------------------+
| <limits> |
|_lib.support.limits_ Implementation properties <climits> |
| <cfloat> |
+--------------------------------------------------------------+
|_lib.support.start.term_ Start and termination <cstdlib> |
+--------------------------------------------------------------+
|_lib.support.dynamic_ Dynamic memory management <new> |
+--------------------------------------------------------------+
|_lib.support.rtti_ Type identification <typeinfo> |
+--------------------------------------------------------------+
|_lib.support.exception_ Exception handling <exception> |
+--------------------------------------------------------------+
| <cstdarg> |
| <csetjmp> |
|_lib.support.runtime_ Other runtime support <ctime> |
| <csignal> |
| <cstdlib> |
+--------------------------------------------------------------+
18.1 Types [lib.support.types]
1 Common definitions.
2 Header <cstddef> (Table 2):
Table 2--Header <cstddef> synopsis
+-----------------------------------+
| Kind Name(s) |
+-----------------------------------+
|Macros: NULL offsetof |
+-----------------------------------+
|Types: ptrdiff_t size_t |
+-----------------------------------+
3 The contents are the same as the Standard C library header <stddef.h>,
with the following changes:
4 The macro NULL is an implementation-defined C++ null-pointer constant
in this International Standard (_conv.ptr_).1)
5 The macro offsetof accepts a restricted set of type arguments in this
International Standard. type shall be a POD structure or a POD union
(_class_).
SEE ALSO: subclause _expr.sizeof_, Sizeof, subclause _expr.add_, Addi
tive operators, subclause _class.free_, Free store, and ISO C sub
clause 7.1.6.
18.2 Implementation properties [lib.support.limits]
1 The headers <limits>, <climits>, and <cfloat> supply charac
teristics of implementation-dependent fundamental types (_basic.funda
mental_).
18.2.1 Numeric limits [lib.limits]
1 The numeric_limits component provides a C++ program with information
about various properties of the implementation's representation of the
fundamental types.
2 Specializations shall be provided for each fundamental type, both
floating point and integer, including bool. The member is_specialized
shall be true for all such specializations of numeric_limits.
3 For all members declared static const in the numeric_limits template,
specializations shall define these values in such a way that they are
usable as integral constant expressions.
_________________________
1) Possible definitions include 0 and 0L, but not (void*)0.
4 Non-fundamental types, such as complex<T> (_lib.complex_), shall not
have specializations.
Header <limits> synopsis
namespace std {
template<class T> class numeric_limits;
enum float_round_style;
class numeric_limits<bool>;
class numeric_limits<char>;
class numeric_limits<signed char>;
class numeric_limits<unsigned char>;
class numeric_limits<wchar_t>;
class numeric_limits<short>;
class numeric_limits<int>;
class numeric_limits<long>;
class numeric_limits<unsigned short>;
class numeric_limits<unsigned int>;
class numeric_limits<unsigned long>;
class numeric_limits<float>;
class numeric_limits<double>;
class numeric_limits<long double>;
}
18.2.1.1 Template class numeric_limits [lib.numeric.limits]
namespace std {
template<class T> class numeric_limits {
public:
static const bool is_specialized = false;
static T min() throw();
static T max() throw();
static const int digits = 0;
static const int digits10 = 0;
static const bool is_signed = false;
static const bool is_integer = false;
static const bool is_exact = false;
static const int radix = 0;
static T epsilon() throw();
static T round_error() throw();
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const int max_exponent = 0;
static const int max_exponent10 = 0;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const bool has_denorm = false;
static const bool has_denorm_loss = false;
static T infinity() throw();
static T quiet_NaN() throw();
static T signaling_NaN() throw();
static T denorm_min() throw();
static const bool is_iec559 = false;
static const bool is_bounded = false;
static const bool is_modulo = false;
static const bool traps = false;
static const bool tinyness_before = false;
static const float_round_style round_style = round_toward_zero;
};
}
1 The member is_specialized makes it possible to distinguish between
fundamental types, which have specializations, and non-scalar types,
which do not.
2 The default numeric_limits<T> template shall have all members, but
with 0 or false values.
18.2.1.2 numeric_limits members [lib.numeric.limits.members]
static T min() throw();
Minimum finite value.2)
1 For floating types with denormalization, returns the minimum positive
normalized value.
2 Meaningful for all specializations in which is_bounded != false. or
is_bounded == false && is_signed == false.
static T max() throw();
Maximum finite value.3)
_________________________
2) Equivalent to CHAR_MIN, SHRT_MIN, FLT_MIN, DBL_MIN, etc.
3) Equivalent to CHAR_MAX, SHRT_MAX, FLT_MAX, DBL_MAX, etc.
3 Meaningful for all specializations in which is_bounded != false.
static const int digits;
Number of radix digits which can be represented without change.
4 For built-in integer types, the number of non-sign bits in the repre
sentation.
5 For floating point types, the number of radix digits in the
mantissa.4)
static const int digits10;
Number of base 10 digits which can be represented without change.5)
6 Meaningful for all specializations in which is_bounded != false.
static const bool is_signed;
True if the type is signed.
7 Meaningful for all specializations.
static const bool is_integer;
True if the type is integer.
8 Meaningful for all specializations.
static const bool is_exact;
True if the type uses an exact representation. All integer types are
exact, but not all exact types are integer. For example, rational and
fixed-exponent representations are exact but not integer.
9 Meaningful for all specializations.
static const int radix;
For floating types, specifies the base or radix of the exponent repre
sentation (often 2).6)
_________________________
4) Equivalent to FLT_MANT_DIG, DBL_MANT_DIG, LDBL_MANT_DIG.
5) Equivalent to FLT_DIG, DBL_DIG, LDBL_DIG.
6) Equivalent to FLT_RADIX.
10For integer types, specifies the base of the representation.7)
11Meaningful for all specializations.
static T epsilon() throw();
Machine epsilon: the difference between 1 and the least value greater
than 1 that is representable.8)
12Meaningful for all floating point types.
static T round_error() throw();
Measure of the maximum rounding error.9)
static const int min_exponent;
Minimum negative integer such that radix raised to the power of one
less than that integer is a normalized floating point number.10)
13Meaningful for all floating point types.
static const int min_exponent10;
Minimum negative integer such that 10 raised to that power is in the
range of normalized floating point numbers.11)
14Meaningful for all floating point types.
static const int max_exponent;
Maximum positive integer such that radix raised to the power one less
than that integer is a representable finite floating point number.12)
15Meaningful for all floating point types.
static const int max_exponent10;
_________________________
7) Distinguishes types with bases other than 2 (e.g. BCD).
8) Equivalent to FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON.
9) Rounding error is described in ISO/IEC 10967-1 Language independent
arithmetic - Part 1 Section 5.2.8 and Annex A Rationale Section
A.5.2.8 - Rounding constants.
10) Equivalent to FLT_MIN_EXP, DBL_MIN_EXP, LDBL_MIN_EXP.
11) Equivalent to FLT_MIN_10_EXP, DBL_MIN_10_EXP, LDBL_MIN_10_EXP.
12) Equivalent to FLT_MAX_EXP, DBL_MAX_EXP, LDBL_MAX_EXP.
Maximum positive integer such that 10 raised to that power is in the
range of representable finite floating point numbers.13)
16Meaningful for all floating point types.
static const bool has_infinity;
True if the type has a representation for positive infinity.
17Meaningful for all floating point types.
18Shall be true for all specializations in which is_iec559 != false.
static const bool has_quiet_NaN;
True if the type has a representation for a quiet (non-signaling)
``Not a Number.''14)
19Meaningful for all floating point types.
20Shall be true for all specializations in which is_iec559 != false.
static const bool has_signaling_NaN;
True if the type has a representation for a signaling ``Not a
Number.''15)
21Meaningful for all floating point types.
22Shall be true for all specializations in which is_iec559 != false.
static const bool has_denorm;
True if the type allows denormalized values (variable number of expo
nent bits).16)
23Meaningful for all floating point types.
static const bool has_denorm_loss;
True if loss of accuracy is detected as a denormalization loss, rather
than as an inexact result.17)
_________________________
13) Equivalent to FLT_MAX_10_EXP, DBL_MAX_10_EXP, LDBL_MAX_10_EXP.
14) Required by LIA-1.
15) Required by LIA-1.
16) Required by LIA-1.
17) See IEC 559.
static T infinity() throw();
Representation of positive infinity, if available.18)
24Meaningful for all specializations for which has_infinity != false.
Required in specializations for which is_iec559 != false.
static T quiet_NaN() throw();
Representation of a quiet ``Not a Number,'' if available.19)
25Meaningful for all specializations for which has_quiet_NaN != false.
Required in specializations for which is_iec559 != false.
static T signaling_NaN() throw();
Representation of a signaling ``Not a Number,'' if available.20)
26Meaningful for all specializations for which has_signaling_NaN !=
false. Required in specializations for which is_iec559 != false.
static T denorm_min() throw();
Minimum positive denormalized value.21)
27Meaningful for all floating point types.
28In specializations for which has_denorm == false, returns the minimum
positive normalized value.
static const bool is_iec559;
True if and only if the type adheres to IEC 559 standard.22)
29Meaningful for all floating point types.
static const bool is_bounded;
True if the set of values representable by the type is finite.23) All
_________________________
18) Required by LIA-1.
19) Required by LIA-1.
20) Required by LIA-1.
21) Required by LIA-1.
22) International Electrotechnical Commission standard 559 is the same
as IEEE 754.
23) Required by LIA-1.
built-in types are bounded, this member would be false for arbitrary
precision types.
30Meaningful for all specializations.
static const bool is_modulo;
True if the type is modulo.24) A type is modulo if it is possible to
add two positive numbers and have a result which wraps around to a
third number which is less.
31Generally, this is false for floating types, true for unsigned inte
gers, and true for signed integers on most machines.
32Meaningful for all specializations.
static const bool traps;
true if trapping is implemented for the type.25)
33Meaningful for all specializations.
static const bool tinyness_before;
true if tinyness is detected before rounding.26)
34Meaningful for all floating point types.
static const float_round_style round_style;
The rounding style for the type.27)
35Meaningful for all floating point types. Specializations for integer
types shall return round_toward_zero.
18.2.1.3 Type float_round_style [lib.round.style]
_________________________
24) Required by LIA-1.
25) Required by LIA-1.
26) Refer to IEC 559. Required by LIA-1.
27) Equivalent to FLT_ROUNDS. Required by LIA-1.
namespace std {
enum float_round_style {
round_indeterminate = -1,
round_toward_zero = 0,
round_to_nearest = 1,
round_toward_infinity = 2,
round_toward_neg_infinity = 3
};
}
1 The rounding mode for floating point arithmetic is characterized by
the values:
--round_indeterminate if the rounding style is indeterminable
--round_toward_zero if the rounding style is toward zero
--round_to_nearest if the rounding style is to the nearest repre
sentable value
--round_toward_infinity if the rounding style is toward infinity
--round_toward_neg_infinity if the rounding style is toward negative
infinity
18.2.1.4 numeric_limits specializations [lib.numeric.special]
1 All members shall be provided for all specializations. However, many
values are only required to be meaningful under certain conditions
(for example, epsilon() is only meaningful if is_integer is false).
Any value which is not ``meaningful'' shall be set to 0 or false.
2 [Example:
namespace std {
class numeric_limits<float> {
public:
static const bool is_specialized = true;
inline static float min() throw() { return 1.17549435E-38F; }
inline static float max() throw() { return 3.40282347E+38F; }
static const int digits = 24;
static const int digits10 = 6;
static const bool is_signed = true;
static const bool is_integer = false;
static const bool is_exact = false;
static const int radix = 2;
inline static float epsilon() throw() { return 1.19209290E-07F; }
inline static float round_error() throw() { return 0.5F; }
static const int min_exponent = -125;
static const int min_exponent10 = - 37;
static const int max_exponent = +128;
static const int max_exponent10 = + 38;
static const bool has_infinity = true;
static const bool has_quiet_NaN = true;
static const bool has_signaling_NaN = true;
static const bool has_denorm = false;
static const bool has_denorm_loss = false;
inline static float infinity() throw() { return ...; }
inline static float quiet_NaN() throw() { return ...; }
inline static float signaling_NaN() throw() { return ...; }
inline static float denorm_min() throw() { return min(); }
static const bool is_iec559 = true;
static const bool is_bounded = true;
static const bool is_modulo = false;
static const bool traps = true;
static const bool tinyness_before = true;
static const float_round_style round_style = round_to_nearest;
};
}
--end example]
18.2.2 C Library [lib.c.limits]
1 Header <climits> (Table 3):
Table 3--Header <climits> synopsis
+---------------------------------------------------------------------+
| Type Name(s) |
+---------------------------------------------------------------------+
|Values: |
|CHAR_BIT INT_MAX LONG_MIN SCHAR_MIN UCHAR_MAX USHRT_MAX |
|CHAR_MAX INT_MIN MB_LEN_MAX SHRT_MAX UINT_MAX |
|CHAR_MIN LONG_MAX SCHAR_MAX SHRT_MIN ULONG_MAX |
+---------------------------------------------------------------------+
2 The contents are the same as the Standard C library header <limits.h>.
3 Header <cfloat> (Table 4):
Table 4--Header <cfloat> synopsis
+-------------------------------------------------------------------+
| Type Name(s) |
+-------------------------------------------------------------------+
|Values: |
|DBL_DIG DBL_MIN_EXP FLT_MIN_10_EXP LDBL_MAX_10_EXP |
|DBL_EPSILON FLT_DIG FLT_MIN_EXP LDBL_MAX_EXP |
|DBL_MANT_DIG FLT_EPSILON FLT_RADIX LDBL_MIN |
|DBL_MAX FLT_MANT_DIG FLT_ROUNDS LDBL_MIN_10_EXP |
|DBL_MAX_10_EXP FLT_MAX LDBL_DIG LDBL_MIN_EXP |
|DBL_MAX_EXP FLT_MAX_10_EXP LDBL_EPSILON |
|DBL_MIN FLT_MAX_EXP LDBL_MANT_DIG |
|DBL_MIN_10_EXP FLT_MIN LDBL_MAX |
+-------------------------------------------------------------------+
4 The contents are the same as the Standard C library header <float.h>.
SEE ALSO: ISO C subclause 7.1.5, 5.2.4.2.2, 5.2.4.2.1.
18.3 Start and termination [lib.support.start.term]
1 Header <cstdlib> (partial), Table 5:
Table 5--Header <cstdlib> synopsis
+-------------------------------------------+
| Type Name(s) |
+-------------------------------------------+
|Macros: EXIT_FAILURE EXIT_SUCCESS |
+-------------------------------------------+
|Functions: abort atexit exit |
+-------------------------------------------+
2 The contents are the same as the Standard C library header <stdlib.h>,
with the following changes:
atexit(void (*f)(void))
3 The function atexit(), has additional behavior in this International
Standard:
--For the execution of a function registered with atexit, if control
leaves the function because it provides no handler for a thrown
exception, terminate() is called (_lib.terminate_).
exit(int status)
4 The function exit() has additional behavior in this International
Standard:
--First, objects with static storage duration are destroyed and func
tions registered by calling atexit are called. Objects with static
storage duration are destroyed in the reverse order of the comple
tion of their constructor. (Automatic objects are not destroyed as
a result of calling exit().)28) Functions registered with atexit are
called in the reverse order of their registration.29) A function
registered with atexit before an object obj1 of static storage dura
tion is initialized will not be called until obj1's destruction has
completed. A function registered with atexit after an object obj2
of static storage duration is initialized will be called before
obj2's destruction starts.
--Next, all open C streams (as mediated by the function signatures
declared in <cstdio>) with unwritten buffered data are flushed, all
open C streams are closed, and all files created by calling tmp
file() are removed.30)
--Finally, control is returned to the host environment. If status is
zero or EXIT_SUCCESS, an implementation-defined form of the status
successful termination is returned. If status is EXIT_FAILURE, an
implementation-defined form of the status unsuccessful termination
is returned. Otherwise the status returned is
implementation-defined.31)
5 The function exit() never returns to its caller.
SEE ALSO: subclauses _basic.start_, _basic.start.term_, ISO C sub
clause 7.10.4.
18.4 Dynamic memory management [lib.support.dynamic]
1 The header <new> defines several functions that manage the allocation
of dynamic storage in a program. It also defines components for
reporting storage management errors.
Header <new> synopsis
_________________________
28) Objects with automatic storage duration are all destroyed in a
program whose function main() contains no automatic objects and exe
cutes the call to exit(). Control can be transferred directly to such
a main() by throwing an exception that is caught in main().
29) A function is called for every time it is registered.
30) Any C streams associated with cin, cout, etc (_lib.iostream.ob
jects_) are flushed and closed when static objects are destroyed in
the previous phase. The function tmpfile() is declared in <cstdio>.
31) The macros EXIT_FAILURE and EXIT_SUCCESS are defined in <cstdlib>.
namespace std {
class bad_alloc;
struct nothrow_t {};
extern const nothrow_t nothrow;
typedef void (*new_handler)();
new_handler set_new_handler(new_handler new_p) throw();
}
void* operator new(size_t size) throw(std::bad_alloc);
void* operator new(size_t size, const std::nothrow_t&) throw();
void operator delete(void* ptr) throw();
void operator delete(void* ptr, const std::nothrow_t&) throw();
void* operator new[](size_t size) throw(std::bad_alloc);
void* operator new[](size_t size, const std::nothrow_t&) throw();
void operator delete[](void* ptr) throw();
void operator delete[](void* ptr, const std::nothrow_t&) throw();
void* operator new (size_t size, void* ptr) throw();
void* operator new[](size_t size, void* ptr) throw();
void operator delete (void* ptr, void*) throw();
void operator delete[](void* ptr, void*) throw();
SEE ALSO: subclauses _intro.memory_, _basic.stc.dynamic_, _expr.new_,
_expr.delete_, _class.free_, _lib.memory_.
18.4.1 Storage allocation and deallocation [lib.new.delete]
18.4.1.1 Single-object forms [lib.new.delete.single]
void* operator new(size_t size) throw(bad_alloc);
Effects:
The allocation function (_basic.stc.dynamic.allocation_) called by a
new-expression (_expr.new_) to allocate size bytes of storage suit
ably aligned to represent any object of that size.
Replaceable:
a C++ program may define a function with this function signature
that displaces the default version defined by the C++ Standard
library.
Required behavior:
Return a pointer to dynamically allocated storage
(_basic.stc.dynamic_), or else throw a bad_alloc exception.
Default behavior:
--Executes a loop: Within the loop, the function first attempts to
allocate the requested storage. Whether the attempt involves a call
to the Standard C library function malloc is unspecified.
--Returns a pointer to the allocated storage if the attempt is suc
cessful. Otherwise, if the last argument to set_new_handler() was a
null pointer, throw bad_alloc.
--Otherwise, the function calls the current new_handler (_lib.new.han
dler_). If the called function returns, the loop repeats.
--The loop terminates when an attempt to allocate the requested stor
age is successful or when a called new_handler function does not
return.
void* operator new(size_t size, const nothrow_t&) throw();
Effects:
Same as above, except that it is called by a placement version of a
new-expression when a C++ program prefers a null pointer result as
an error indication, instead of a bad_alloc exception.
Replaceable:
a C++ program may define a function with this function signature
that displaces the default version defined by the C++ Standard
library.
Required behavior:
Return a pointer to dynamically allocated storage
(_basic.stc.dynamic_), or else return a null pointer. This nothrow
version of operator new returns a pointer obtained as if acquired
from the ordinary version. This requirement is binding on a
replacement version of this function.
Default behavior:
--Executes a loop: Within the loop, the function first attempts to
allocate the requested storage. Whether the attempt involves a call
to the Standard C library function malloc is unspecified.
--Returns a pointer to the allocated storage if the attempt is suc
cessful. Otherwise, if the last argument to set_new_handler() was a
null pointer, return a null pointer.
--Otherwise, the function calls the current new_handler (_lib.new.han
dler_). If the called function returns, the loop repeats.
--The loop terminates when an attempt to allocate the requested stor
age is successful or when a called new_handler function does not
return. If the called new_handler function terminates by throwing a
bad_alloc exception, the function returns a null pointer.
1 [Example:
T* p1 = new T; // throws bad_alloc if it fails
T* p2 = new(nothrow) T; // returns 0 if it fails
--end example]
void operator delete(void* ptr) throw();
void operator delete(void* ptr, const std::nothrow_t&) throw();
Effects:
The deallocation function (_basic.stc.dynamic.deallocation_) called
by a delete-expression to render the value of ptr invalid.
Replaceable:
a C++ program may define a function with this function signature
that displaces the default version defined by the C++ Standard
library.
Required behavior:
accept a value of ptr that is null or that was returned by an ear
lier call to the default operator new(size_t) or operator
new(size_t,const nothrow_t&).
Default behavior:
--For a null value of ptr, do nothing.
--Any other value of ptr shall be a value returned earlier by a call
to the default operator new, which was not invalidated by an inter
vening call to operator delete(void*) (_lib.res.on.arguments_). For
such a non-null value of ptr, reclaims storage allocated by the ear
lier call to the default operator new.
Notes:
It is unspecified under what conditions part or all of such
reclaimed storage is allocated by a subsequent call to operator new
or any of calloc, malloc, or realloc, declared in <cstdlib>.
18.4.1.2 Array forms [lib.new.delete.array]
void* operator new[](size_t size) throw(bad_alloc);
Effects:
The allocation function (_basic.stc.dynamic.allocation_) called by
the array form of a new-expression (_expr.new_) to allocate size
bytes of storage suitably aligned to represent any array object of
that size or smaller.32)
Replaceable:
a C++ program can define a function with this function signature
that displaces the default version defined by the C++ Standard
library.
Required behavior:
Same as for operator new(size_t). This nothrow version of operator
new[] returns a pointer obtained as if acquired from the ordinary
version. This requirement is binding on a replacement version of
this function.
Default behavior:
Returns operator new(size).
void* operator new[](size_t size, const nothrow_t&) throw();
_________________________
32) It is not the direct responsibility of operator new[](size_t) or
operator delete[](void*) to note the repetition count or element size
of the array. Those operations are performed elsewhere in the array
new and delete expressions. The array new expression, may, however,
increase the size argument to operator new[](size_t) to obtain space
to store supplemental information.
Effects:
Same as above, except that it is called by a placement version of a
new-expression when a C++ program prefers a null pointer result as
an error indication, instead of a bad_alloc exception.
Replaceable:
a C++ program can define a function with this function signature
that displaces the default version defined by the C++ Standard
library.
Required behavior:
Same as for operator new(size_t,const nothrow_t&).
Default behavior:
Returns operator new(size,nothrow).
void operator delete[](void* ptr) throw();
void operator delete[](void* ptr, const std::nothrow_t&) throw();
Effects:
The deallocation function (_basic.stc.dynamic.deallocation_) called
by the array form of a delete-expression to render the value of ptr
invalid.
Replaceable:
a C++ program can define a function with this function signature
that displaces the default version defined by the C++ Standard
library.
Required behavior:
accept a value of ptr that is null or that was returned by an ear
lier call to operator new[](size_t) or operator new[](size_t,const
std::nothrow_t&).
Default behavior:
--For a null value of ptr, does nothing.
--Any other value of ptr shall be a value returned earlier by a call
to the default operator new[](size_t).33) For such a non-null value
of ptr, reclaims storage allocated by the earlier call to the
default operator new[].
1 It is unspecified under what conditions part or all of such reclaimed
storage is allocated by a subsequent call to operator new or any of
calloc, malloc, or realloc, declared in <cstdlib>.
18.4.1.3 Placement forms [lib.new.delete.placement]
1 These functions are reserved, a C++ program may not define functions
that displace the versions in the Standard C++ library (_lib.con
straints_).
_________________________
33) The value must not have been invalidated by an intervening call to
operator delete[](void*) (_lib.res.on.arguments_).
void* operator new(size_t size, void* ptr) throw();
Returns:
ptr.
Notes:
Intentionally performs no other action.
2 [Example: This can be useful for constructing an object at a known
address:
char place[sizeof(Something)];
Something* p = new (place) Something();
--end example]
void* operator new[](size_t size, void* ptr) throw();
Returns:
ptr.
Notes:
Intentionally performs no other action.
void operator delete(void* ptr, void*) throw();
Effects:
Intentionally performs no action.
Notes:
Default function called for a placement delete expression. Comple
ments default placement new.
void operator delete[](void* ptr, void*) throw();
Effects:
Intentionally performs no action.
Notes:
Default function called for a placement array delete expression.
Complements default placement new[].
18.4.2 Storage allocation errors [lib.alloc.errors]
18.4.2.1 Class bad_alloc [lib.bad.alloc]
namespace std {
class bad_alloc : public exception {
public:
bad_alloc() throw();
bad_alloc(const bad_alloc&) throw();
bad_alloc& operator=(const bad_alloc&) throw();
virtual ~bad_alloc() throw();
virtual const char* what() const throw();
};
}
1 The class bad_alloc defines the type of objects thrown as exceptions
by the implementation to report a failure to allocate storage.
bad_alloc() throw();
Effects:
Constructs an object of class bad_alloc.
bad_alloc(const bad_alloc&) throw();
bad_alloc& operator=(const bad_alloc&) throw();
Effects:
Copies an object of class bad_alloc.
Notes:
The result of calling what() on the newly constructed object is
implementation-defined.
virtual const char* what() const throw();
Returns:
An implementation-defined value.
18.4.2.2 Type new_handler [lib.new.handler]
typedef void (*new_handler)();
1 The type of a handler function to be called by operator new() or oper
ator new[]() (_lib.new.delete_) when they cannot satisfy a request for
additional storage.
Required behavior:
A new_handler shall perform one of the following:
--make more storage available for allocation and then return;
--throw an exception of type bad_alloc or a class derived from
bad_alloc;
--call either abort() or exit();
Default behavior:
The implementation's default new_handler throws an exception of type
bad_alloc.
18.4.2.3 set_new_handler [lib.set.new.handler]
new_handler set_new_handler(new_handler new_p) throw();
Effects:
Establishes the function designated by new_p as the current new_han
dler.
Returns:
the previous new_handler.
18.5 Type identification [lib.support.rtti]
1 The header <typeinfo> defines a type associated with type information
generated by the implementation. It also defines two types for
reporting dynamic type identification errors.
Header <typeinfo> synopsis
namespace std {
class type_info;
class bad_cast;
class bad_typeid;
}
SEE ALSO: subclauses _expr.dynamic.cast_, _expr.typeid_.
18.5.1 Class type_info [lib.type.info]
namespace std {
class type_info {
public:
virtual ~type_info();
bool operator==(const type_info& rhs) const;
bool operator!=(const type_info& rhs) const;
bool before(const type_info& rhs) const;
const char* name() const;
private:
type_info(const type_info& rhs);
type_info& operator=(const type_info& rhs);
};
}
1 The class type_info describes type information generated by the imple
mentation. Objects of this class effectively store a pointer to a
name for the type, and an encoded value suitable for comparing two
types for equality or collating order. The names, encoding rule, and
collating sequence for types are all unspecified and may differ
between programs.
bool operator==(const type_info& rhs) const;
Effects:
Compares the current object with rhs.
Returns:
true if the two values describe the same type.
bool operator!=(const type_info& rhs) const;
Returns:
!(*this == rhs).
bool before(const type_info& rhs) const;
Effects:
Compares the current object with rhs.
Returns:
true if *this precedes rhs in the implementation's collation order.
const char* name() const;
Returns:
an implementation-defined value.
Notes:
The message may be a null-terminated multibyte string (_lib.multi
byte.strings_), suitable for conversion and display as a wstring
(_lib.string.classes_, _lib.locale.codecvt_)
type_info(const type_info& rhs);
type_info& operator=(const type_info& rhs);
Effects:
Copies a type_info object.
Notes:
Since the copy constructor and assignment operator for type_info are
private to the class, objects of this type cannot be copied.
18.5.2 Class bad_cast [lib.bad.cast]
namespace std {
class bad_cast : public exception {
public:
bad_cast() throw();
bad_cast(const bad_cast&) throw();
bad_cast& operator=(const bad_cast&) throw();
virtual ~bad_cast() throw();
virtual const char* what() const throw();
};
}
1 The class bad_cast defines the type of objects thrown as exceptions by
the implementation to report the execution of an invalid dynamic-cast
expression (_expr.dynamic.cast_).
bad_cast() throw();
Effects:
Constructs an object of class bad_cast.
bad_cast(const bad_cast&) throw();
bad_cast& operator=(const bad_cast&) throw();
Effects:
Copies an object of class bad_cast.
Notes:
The result of calling what() on the newly constructed object is
implementation-defined.
virtual const char* what() const throw();
Returns:
An implementation-defined value.
Notes:
The message may be a null-terminated multibyte string (_lib.multi
byte.strings_), suitable for conversion and display as a wstring
(_lib.string.classes_, _lib.locale.codecvt_)
18.5.3 Class bad_typeid [lib.bad.typeid]
namespace std {
class bad_typeid : public exception {
public:
bad_typeid() throw();
bad_typeid(const bad_typeid&) throw();
bad_typeid& operator=(const bad_typeid&) throw();
virtual ~bad_typeid() throw();
virtual const char* what() const throw();
};
}
1 The class bad_typeid defines the type of objects thrown as exceptions
by the implementation to report a null pointer in a typeid expression
(_expr.typeid_).
bad_typeid() throw();
Effects:
Constructs an object of class bad_typeid.
bad_typeid(const bad_typeid&) throw();
bad_typeid& operator=(const bad_typeid&) throw();
Effects:
Copies an object of class bad_typeid.
Notes:
The result of calling what() on the newly constructed object is
implementation-defined.
virtual const char* what() const throw();
Returns:
An implementation-defined value.
Notes:
The message may be a null-terminated multibyte string (_lib.multi
byte.strings_), suitable for conversion and display as a wstring
(_lib.string.classes_, _lib.locale.codecvt_)
18.6 Exception handling [lib.support.exception]
1 The header <exception> defines several types and functions related to
the handling of exceptions in a C++ program.
Header <exception> synopsis
namespace std {
class exception;
class bad_exception;
typedef void (*unexpected_handler)();
unexpected_handler set_unexpected(unexpected_handler f) throw();
void unexpected();
typedef void (*terminate_handler)();
terminate_handler set_terminate(terminate_handler f) throw();
void terminate();
bool uncaught_exception();
}
SEE ALSO: subclause _except.special_.
18.6.1 Class exception [lib.exception]
namespace std {
class exception {
public:
exception() throw();
exception(const exception&) throw();
exception& operator=(const exception&) throw();
virtual ~exception() throw();
virtual const char* what() const throw();
};
}
1 The class exception defines the base class for the types of objects
thrown as exceptions by C++ Standard library components, and certain
expressions, to report errors detected during program execution.
exception() throw();
Effects:
Constructs an object of class exception.
Notes:
Does not throw any exceptions.
exception(const exception&) throw();
exception& operator=(const exception&) throw();
Effects:
Copies an exception object.
Notes:
The effects of calling what() after assignment are implementation-
defined.
virtual ~exception() throw();
Effects:
Destroys an object of class exception.
Notes:
Does not throw any exceptions.
virtual const char* what() const throw();
Returns:
An implementation-defined NTBS.
Notes:
The message may be a null-terminated multibyte string (_lib.multi
byte.strings_), suitable for conversion and display as a wstring
(_lib.string.classes_, _lib.locale.codecvt_)
18.6.2 Violating exception- [lib.exception.unexpected]
specifications
18.6.2.1 Class bad_exception [lib.bad.exception]
namespace std {
class bad_exception : public exception {
public:
bad_exception() throw();
bad_exception(const bad_exception&) throw();
bad_exception& operator=(const bad_exception&) throw();
virtual ~bad_exception() throw();
virtual const char* what() const throw();
};
}
1 The class bad_exception defines the type of objects thrown as
described in (_except.unexpected_).
bad_exception() throw();
Effects:
Constructs an object of class bad_exception.
bad_exception(const bad_exception&) throw();
bad_exception& operator=(const bad_exception&) throw();
Effects:
Copies an object of class bad_exception.
Notes:
The result of calling what() on the newly constructed object is
implementation-defined.
virtual const char* what() const throw();
Returns:
An implementation-defined value.
Notes:
The message may be a null-terminated multibyte string (_lib.multi
byte.strings_), suitable for conversion and display as a wstring
(_lib.string.classes_, _lib.locale.codecvt_)
18.6.2.2 Type unexpected_handler [lib.unexpected.handler]
typedef void (*unexpected_handler)();
1 The type of a handler function to be called by unexpected() when a
function attempts to throw an exception not listed in its exception-
specification.
Required behavior:
an unexpected_handler shall either throw an exception or terminate
execution of the program without returning to the caller. An unex
pected_handler may perform any of the following:
--throw an exception that satisfies the exception specification;
--throw an exception of class bad_exception or of any class directly
or indirectly derived from bad_exception;
--call terminate();
--call either abort() or exit();
Default behavior:
The implementation's default unexpected_handler calls terminate().
18.6.2.3 set_unexpected [lib.set.unexpected]
unexpected_handler set_unexpected(unexpected_handler f) throw();
Effects:
Establishes the function designated by f as the current unex
pected_handler.
Requires:
f shall not be a null pointer.
Returns:
The previous unexpected_handler.
18.6.2.4 unexpected [lib.unexpected]
void unexpected();
1 Called when a function exits via an exception not allowed by its
exception-specification (_except.unexpected_).
Effects:
Calls the unexpected_handler function in effect immediately after
evaluating the throw-expression (_lib.unexpected.handler_).
18.6.3 Abnormal termination [lib.exception.terminate]
18.6.3.1 Type terminate_handler [lib.terminate.handler]
typedef void (*terminate_handler)();
1 The type of a handler function to be called by terminate() when termi
nating exception processing.
Required behavior:
A terminate_handler shall terminate execution of the program without
returning to the caller.
Default behavior:
The implementation's default terminate_handler calls abort().
18.6.3.2 set_terminate [lib.set.terminate]
terminate_handler set_terminate(terminate_handler f) throw();
Effects:
Establishes the function designated by f as the current handler
function for terminating exception processing.
Requires:
f shall not be a null pointer.
Returns:
The previous terminate_handler.
18.6.3.3 terminate [lib.terminate]
void terminate();
1 Called by the implementation when exception handling must be abandoned
for any of several reasons (_except.terminate_).
Effects:
Calls the terminate_handler function in effect immediately after
evaluating the throw-expression (_lib.terminate.handler_).
18.6.4 uncaught_exception [lib.uncaught]
bool uncaught_exception();
Returns:
true after completing evaluation of a throw-expression until com
pleting initialization of the exception-declaration in the matching
handler (_except.uncaught_). This includes stack unwinding
(_except.ctor_).
Notes:
When uncaught_exception() is true, throwing an exception can result
in a call of terminate (_except.terminate_).
18.7 Other runtime support [lib.support.runtime]
1 Headers <cstdarg> (variable arguments), <csetjmp> (nonlocal jumps),
<ctime> (system clock clock(), time()), <csignal> (signal handling),
and <cstdlib> (runtime environment getenv(), system()).
Table 6--Header <cstdarg> synopsis
+--------------------------------------+
| Type Name(s) |
+--------------------------------------+
|Macros: va_arg va_end va_start |
+--------------------------------------+
|Type: va_list |
+--------------------------------------+
Table 7--Header <csetjmp> synopsis
+--------------------+
| Type Name(s) |
+--------------------+
|Macro: setjmp |
+--------------------+
|Type: jmp_buf |
+--------------------+
|Function: longjmp |
+--------------------+
Table 8--Header <ctime> synopsis
+----------------------------+
| Type Name(s) |
+----------------------------+
|Macros: CLOCKS_PER_SEC |
+----------------------------+
|Types: clock_t |
+----------------------------+
|Functions: clock |
+----------------------------+
Table 9--Header <csignal> synopsis
+-------------------------------------------------------+
| Type Name(s) |
+-------------------------------------------------------+
|Macros: SIGABRT SIGILL SIGSEGV SIG_DFL |
|SIG_IGN SIGFPE SIGINT SIGTERM SIG_ERR |
+-------------------------------------------------------+
|Type: sig_atomic_t |
+-------------------------------------------------------+
|Functions: raise signal |
+-------------------------------------------------------+
Table 10--Header <cstdlib> synopsis
-------------------------------
Type Name(s)
-------------------------------
Functions: getenv system
-------------------------------
| |
| |
| |
2 The contents of these headers are the same as the Standard C library
headers <stdarg.h>, <setjmp.h>, <time.h>, <signal.h>, and <stdlib.h>
respectively, with the following changes:
3 The restrictions that ISO C places on the second parameter to the
va_start() macro in header <stdarg.h> are different in this Interna
tional Standard. The parameter parmN is the identifier of the right
most parameter in the variable parameter list of the function defini
tion (the one just before the ...). If the parameter parmN is
declared with a function, array, or reference type, or with a type
that is not compatible with the type that results when passing an
argument for which there is no parameter, the behavior is undefined.
SEE ALSO: ISO C subclause 4.8.1.1.
4 The function signature longjmp(jmp_buf jbuf, int val) has more
restricted behavior in this International Standard. If any automatic
objects would be destroyed by a thrown exception transferring control
to another (destination) point in the program, then a call to
longjmp(jbuf, val) at the throw point that transfers control to the
same (destination) point has undefined behavior.
SEE ALSO: ISO C subclause 7.10.4, 7.8, 7.6, 7.12.