std::string message() const; (since C++11) Returns the message corresponding to the current error value and category. Equivalent to category().message(value()). Parameters (none). Return value The error message corresponding to the current error value and category. Exceptions (none).

Defined in header <locale> public: iter_type get_weekday( iter_type beg, iter_type end, std::ios_base& str, std::ios_base::iostate& err, std::tm* t) const; (1) protected: virtual iter_type do_get_weekday( iter_type beg, iter_type end, std::ios_base& str, std::ios_base::iostate& err, std::tm* t) const; (2) 1) public member function, calls the protected virtual member function do_get_weekday of th

Defined in header <locale> template< class charT > charT tolower( charT ch, const locale& loc ); Converts the character ch to lowercase if possible, using the conversion rules specified by the given locale's std::ctype facet. Parameters ch - character loc - locale Return value Returns the lowercase form of ch if one is listed in the locale, otherwise return ch unchanged. Notes Only 1:1 character mapping can be performed by this function, e.g

Defined in header <memory> template< class T, class... Args > static void construct( Alloc& a, T* p, Args&&... args ); (since C++11) If possible, constructs an object of type T in allocated uninitialized storage pointed to by p, by calling. a.construct(p, std::forward<Args>(args)...). If the above is not possible (e.g. a does not have the member function construct(),), then calls placement-new as. ::new (static_cast<void*>(p)) T(std::forward<

void push_front( const T& value ); void push_front( T&& value ); (since C++11) Prepends the given element value to the beginning of the container. All iterators, including the past-the-end iterator, are invalidated. No references are invalidated. Parameters value - the value of the element to prepend Return value (none). Complexity Constant. Exceptions If an exception is thrown, this function has no effect (strong exception guarantee). See also

allocator_type get_allocator() const; (since C++11) Returns the allocator associated with the object. Parameters (none). Return value The associated allocator. Complexity Constant.

Defined in header <cstdarg> typedef /* unspecified */ va_list; va_list is a complete object type suitable for holding the information needed by the macros va_start, va_copy, va_arg, and va_end. If a va_list instance is created, passed to another function, and used via va_arg in that function, then any subsequent use in the calling function should be preceded by a call to va_end. It is legal to pass a pointer to a va_list object to another function and then use that object a

Defined in header <regex> typedef /*unspecified*/ match_flag_type; constexpr match_flag_type match_default = 0; constexpr match_flag_type match_not_bol = /*unspecified*/; constexpr match_flag_type match_not_eol = /*unspecified*/; constexpr match_flag_type match_not_bow = /*unspecified*/; constexpr match_flag_type match_not_eow = /*unspecified*/; constexpr match_flag_type match_any = /*unspecified*/; constexpr match_flag_type match_not_null = /*unspecified*/; constexpr match_flag_t

Defined in header <cmath> #define INFINITY /*implementation defined*/ (since C++11) If the implementation supports floating-point infinities, the macro INFINITY expands to constant expression of type float which evaluates to positive or unsigned infinity. If the implementation does not support floating-point infinities, the macro INFINITY expands to a positive value that is guaranteed to overflow a float at compile time, and the use of this macro generates a compiler warnin

shared_ptr<T> shared_from_this(); (1) shared_ptr<T const> shared_from_this() const; (2) Returns a std::shared_ptr<T> that shares ownership of *this with all existing std::shared_ptr that refer to *this. Notes Before calling shared_from_this, there should be at least one std::shared_ptr p that owns *this. Return value std::shared_ptr<T> that shares ownership of *this with pre-existing std::shared_ptrs. Example #include <iostream> #include &l