Defined in header <functional> template< class Arg, class Result > std::pointer_to_unary_function<Arg,Result> ptr_fun( Result (*f)(Arg) ); (1) (until C++17)(deprecated since C++11) template< class Arg1, class Arg2, class Result > std::pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun( Result (*f)(Arg1, Arg2) ); (2) (until C++17)(deprecated since C++11) Creates a function wrapper object (either std::pointer_to_unary_function or std::p

Defined in header <locale> (1) public: iter_type put( iter_type out, std::ios_base& str, char_type fill, bool v ) const; iter_type put( iter_type out, std::ios_base& str, char_type fill, long v ) const; iter_type put( iter_type out, std::ios_base& str, char_type fill, long long v ) const; iter_type put( iter_type out, std::ios_base& str, char_type fill, unsigned long v ) const; iter_type put( iter_type out, std::ios_base& str, char_type fi

Defined in header <ratio> template< class R1, class R2 > using ratio_subtract = /* see below */; The alias template std::ratio_subtract denotes the result of subtracting two exact rational fractions represented by the std::ratio specializations R1 and R2. The result is a std::ratio specialization std::ratio<U, V>, such that given Num == R1::num * R2::den - R2::num * R1::den and Denom == R1::den * R2::den (computed without arithmetic overflow), U is std::ratio<

Defined in header <ratio> template< class R1, class R2 > struct ratio_equal : std::integral_constant; If the ratios R1 and R2 are equal, provides the member constant value equal true. Otherwise, value is false. Helper variable template template< class R1, class R2 > constexpr bool ratio_equal_v = ratio_equal<R1, R2>::value; (since C++17) Inherited from std::integral_constant Member constants value [static] true if R1::num == R2::num

Defined in header <ratio> template< class R1, class R2 > using ratio_divide = /* see below */; The alias template std::ratio_divide denotes the result of dividing two exact rational fractions represented by the std::ratio specializations R1 and R2. The result is a std::ratio specialization std::ratio<U, V>, such that given Num == R1::num * R2::den and Denom == R1::den * R2::num (computed without arithmetic overflow), U is std::ratio<Num, Denom>::num and V

Establishes an exception handler around the body of a function. Syntax The function-try-block is one of the alternative syntax forms for function-body, which is a part of function definition. try ctor-initializer(optional) compound-statement handler-sequence ctor-initializer - member initializer list, only allowed in constructors compound-statement - the brace-enclosed sequence of statements that constututes the body of a function handler-sequence - sequence of one o

Defined in header <locale> public: const CharT* scan_is( mask m, const CharT* beg, const CharT* end ) const; (1) protected: virtual const CharT* do_scan_is( mask m, const CharT* beg, const CharT* end) const; (2) 1) public member function, calls the protected virtual member function do_scan_is of the most derived class. 2) Locates the first character in the character array [beg, end) that satisfies the classification mask m, that is, the first character c such that i

template< class Clock, class Duration > bool try_lock_shared_until( const std::chrono::time_point<Clock,Duration>& timeout_time ); (since C++14) Tries to lock the mutex in shared mode. Blocks until specified timeout_time has been reached or the lock is acquired, whichever comes first. On successful lock acquisition returns true, otherwise returns false. If timeout_time has already passed, this function behaves like try_lock_shared(). The clock tied to timeout_time is use

template< class T > complex<T> operator+( const complex<T>& lhs, const complex<T>& rhs); (1) template< class T > complex<T> operator+( const complex<T>& lhs, const T& rhs); (2) template< class T > complex<T> operator+( const T& lhs, const complex<T>& rhs); (3) template< class T > complex<T> operator-( const complex<T>& lhs, const complex<T>& rhs); (4) temp

An identifier is an arbitrary long sequence of digits, underscores, lowercase and uppercase Latin letters, and Unicode characters. A valid identifier must begin with a non-digit character (Latin letter, underscore, or Unicode non-digit character). Identifiers are case-sensitive (lowercase and uppercase letters are distinct), and every character is significant. Note: C++ grammar formally requires Unicode characters to be escaped with \u or \U, but due to translation phase 1, that is exactly how