(1) explicit stack( const Container& cont = Container() ); (until C++11) explicit stack( const Container& cont ); (since C++11) explicit stack( Container&& cont = Container() ); (2) (since C++11) stack( const stack& other ); (3) stack( stack&& other ); (4) (since C++11) template< class Alloc > explicit stack( const Alloc& alloc ); (5) (since C++11) template< class Alloc > stack( const Container& cont, const A

Defined in header <cwctype> int iswupper( std::wint_t ch ); Checks if the given wide character is an uppercase letter, i.e. one of ABCDEFGHIJKLMNOPQRSTUVWXYZ or any uppercase letter specific to the current locale. Parameters ch - wide character Return value Non-zero value if the wide character is an uppercase letter, zero otherwise. Example #include <iostream> #include <cwctype> #include <clocale> int main() { wchar_t c = L'\u053d'

float max_load_factor() const; (1) (since C++11) void max_load_factor( float ml ); (2) (since C++11) Manages the maximum load factor (number of elements per bucket). The container automatically increases the number of buckets if the load factor exceeds this threshold. 1) Returns current maximum load factor. 2) Sets the maximum load factor to ml. Parameters ml - new maximum load factor setting Return value 1) current maximum load factor. 2) none. Complexity Constan

Defined in header <locale> const mask* table() const; (1) Returns the classification table that was provided in the constructor of this instance of std::ctype<char>, or returns a copy of classic_table() if none was provided. Parameters (none). Return value A pointer to the first element in the classification table (which an array of size std::ctype<char>::table_size). Exceptions (none) (until C++11) noexcept specification: noexcept (since C++11)

Defined in header <limits> template< class T > class numeric_limits; The numeric_limits class template provides a standardized way to query various properties of arithmetic types (e.g. the largest possible value for type int is std::numeric_limits<int>::max()). This information is provided via specializations of the numeric_limits template. The standard library makes available specializations for all arithmetic types: Defined in header <limits> tem

Concept is a term that describes a named set of requirements for a type. Formal specification of concepts (ISO/IEC TS 19217:2015) is an experimental technical specification, which makes it possible to verify that template arguments satisfy the expectations of a template or function during overload resolution and template specialization. The library concepts listed on this page are the named requirements used in the normative text of the C++ standard to define the expectations of the standard li

Defined in header <atomic> #define ATOMIC_FLAG_INIT /* implementation-defined */ Defines the expression which can be used to initialize std::atomic_flag to clear (false) state with the statement std::atomic_flag v = ATOMIC_FLAG_INIT;. It is unspecified if it can be used with other initialization contexts. If the flag has static storage duration, this initialization is static. This is the only way to initialize std::atomic_flag to a definite value: the value held after any o

Defined in header <cmath> float remquo( float x, float y, int* quo ); (1) (since C++11) double remquo( double x, double y, int* quo ); (2) (since C++11) long double remquo( long double x, long double y, int* quo ); (3) (since C++11) Promoted remquo( Arithmetic1 x, Arithmetic2 y, int* quo ); (4) (since C++11) 1-3) Computes the floating-point remainder of the division operation x/y as the std::remainder() function does. Additionally, the sign

Defined in header <cctype> int ispunct( int ch ); Checks if the given character is a punctuation character as classified by the current C locale. The default C locale classifies the characters !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ as punctuation. The behavior is undefined if the value of ch is not representable as unsigned char and is not equal EOF. Parameters ch - character to classify Return value Non-zero value if the character is a punctuation charact

Manipulators are helper functions that make it possible to control input/output streams using operator<< or operator>>. The manipulators that are invoked without arguments (e.g. std::cout << std::boolalpha; or std::cin >> std::hex;) are implemented as functions that take a reference to a stream as their only argument. The special overloads of basic_ostream::operator<< and basic_istream::operator>> accept pointers to these functions. The manipulators that are