Defined in header <atomic> enum memory_order { memory_order_relaxed, memory_order_consume, memory_order_acquire, memory_order_release, memory_order_acq_rel, memory_order_seq_cst }; (since C++11) std::memory_order specifies how regular, non-atomic memory accesses are to be ordered around an atomic operation. Absent any constraints on a multi-core system, when multiple threads simultaneously read and write to several variables, one thread can observe t

static bool sync_with_stdio( bool sync = true ); Sets whether the standard C++ streams are synchronized to the standard C streams after each input/output operation. The standard C++ streams are the following: std::cin, std::cout, std::cerr, std::clog, std::wcin, std::wcout, std::wcerr and std::wclog. The standard C streams are the following: stdin, stdout and stderr. For a standard stream str, synchronized with the C stream f, the following pairs of functions have identical effect: 1)

static int_type eof(); (until C++11) static constexpr int_type eof(); (since C++11) Returns a value not equivalent to any value of type char_type. Parameters (none). Return value A value not equivalent to any value of type char_type. Exceptions (none) (until C++11) noexcept specification: noexcept (since C++11) Complexity Constant. See also not_eof [static] checks whether a character is eof value (public static member function)

Defined in header <memory> template< class T > std::pair< T*, std::ptrdiff_t > get_temporary_buffer( std::ptrdiff_t count ); Allocates uninitialized contiguous storage, which should be sufficient to store up to count adjacent objects of type T. The request is non-binding and the implementation may allocate less or more than necessary to store count adjacent objects. Parameters count - the desired number of objects Return value An std::pair holding

Converts between types with different cv-qualification. Syntax const_cast < new_type > ( expression ) Returns a value of type new_type. Explanation Only the following conversions can be done with const_cast. In particular, only const_cast may be used to cast away (remove) constness or volatility. 1) Two possibly multilevel pointers to the same type may be converted between each other, regardless of cv-qualifiers at each level. 2) lvalue of any type T may be converted to a

Defined in header <complex> template< class T > complex<T> cosh( const complex<T>& z ); (since C++11) Computes complex hyperbolic cosine of a complex value z. Parameters z - complex value Return value If no errors occur, complex hyperbolic cosine of z is returned. Error handling and special values Errors are reported consistent with math_errhandling. If the implementation supports IEEE floating-point arithmetic, std::cosh(std::conj(z

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

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_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 <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