Defined in header <stdexcept> class underflow_error; Defines a type of object to be thrown as exception. It may be used to report arithmetic underflow errors (that is, situations where the result of a computation is a subnormal floating-point value). The standard library components do not throw this exception (mathematical functions report underflow errors as specified in math_errhandling). Third-party libraries, however, use this. For example, boost.math throws std::underf

Defined in header <exception> bool uncaught_exception(); (1) (deprecated in C++17) int uncaught_exceptions(); (2) (since C++17) 1) Detects if the current thread has a live exception object, that is, an exception has been thrown or rethrown and not yet entered a matching catch clause, std::terminate or std::unexpected. In other words, std::uncaught_exception detects if stack unwinding is currently in progress. 2) Detects how many exceptions have been thrown or rethro

Defined in header <memory> template< class T > T* undeclare_reachable( T* p ); (since C++11) Removes the reachable status of the object, referenced by the pointer p, if it was previously set by std::declare_reachable. If the object was declared reachable multiple times, equal number of calls to undeclare_reachable would be needed to remove this status. Once the object is not declared reachable and has no pointers referencing it, it may be reclaimed by garbage collecto

Defined in header <functional> template <typename ArgumentType, typename ResultType> struct unary_function; (until C++17)(deprecated since c++11) unary_function is a base class for creating function objects with one argument. unary_function does not define operator(); it is expected that derived classes will define this. unary_function provides only two types - argument_type and result_type - defined by the template parameters. Some standard library function object ad

Defined in header <typeinfo> class type_info; The class type_info holds implementation-specific information about a type, including the name of the type and means to compare two types for equality or collating order. This is the class returned by the typeid operator. The type_info class is neither CopyConstructible nor CopyAssignable. Member functions (constructor) [deleted] has neither default nor copy constructors (public member function) (destructor) [virtua

Defined in header <functional> template< class Predicate > struct unary_negate : public std::unary_function<Predicate::argument_type, bool>; (until C++11) template< class Predicate > struct unary_negate; (since C++11) unary_negate is a wrapper function object returning the complement of the unary predicate it holds. The unary predicate type must define a member type, argument_type, that is convertible to the predicate's parameter type. The unary func

bool before( const type_info& rhs ); Returns true if the referred type precedes type, referred to by rhs in the implementation's collation order. No guarantees are given, in particular, the collation order can change between the invocations of the same program. Parameters rhs - another type information object to compare to Return value true if the referred type precedes type, referred to by rhs in the implementation's collation order. Example #include <iostream

bool operator==( const type_info& rhs ) const; bool operator!=( const type_info& rhs ) const; Checks if the objects refer to the same types. Parameters rhs - another type information object to compare to Return value true if the comparison operation holds true, false otherwise. Example #include <iostream> #include <typeinfo> #include <string> #include <utility> class person { public: person(std::string&& n) : _nam

size_t hash_code() const; (since C++11) Returns an unspecified value, which is identical for the type_info objects referring to the same type. No other guarantees are given. For example, the same value may be returned for different types. The value can also change between invocations of the same program. Parameters (none). Return value Some value, which is identical for the same types. Example The following program is an example of an efficient type-value mapping without using

const char* name() const; Returns an implementation defined null-terminated character string containing the name of the type. No guarantees are given, in particular, the returned string can be identical for several types and change between invocations of the same program. Parameters (none). Return value null-terminated character string containing the name of the type. Notes With compilers such as gcc and clang, the returned string can be piped through c++filt -t to be converted