template< class Clock, class Duration > bool try_lock_until( const std::chrono::time_point<Clock,Duration>& timeout_time ); (since C++11) Tries to lock the mutex. 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(). The clock tied to timeout_time is used, which means that adjustmen

Defined in header <algorithm> template< class InputIt, class OutputIt, class T > OutputIt remove_copy( InputIt first, InputIt last, OutputIt d_first, const T& value ); (1) template< class InputIt, class OutputIt, class UnaryPredicate > OutputIt remove_copy_if( InputIt first, InputIt last, OutputIt d_first, UnaryPredicate p ); (2) Copies elements from the range [first, last), to another range beginning at d

Defined in header <random> template< class IntType = int > class discrete_distribution; (since C++11) std::discrete_distribution produces random integers on the interval [0, n), where the probability of each individual integer i is defined as wi/S, that is the weight of the ith integer divided by the sum of all n weights. std::discrete_distribution satisfies all requirements of RandomNumberDistribution. Template parameters IntType - The result type generated b

Defined in header <cmath> float fma( float x, float y, float z ); (1) (since C++11) double fma( double x, double y, double z ); (2) (since C++11) long double fma( long double x, long double y, long double z ); (3) (since C++11) Promoted fma( Arithmetic1 x, Arithmetic2 y, Arithmetic3 z ); (4) (since C++11) #define FP_FAST_FMA /* implementation-defined */ (5) (since C++11) #define FP_FAST_FMAF /* implementation-defined */ (6) (since C

Defined in header <type_traits> template< class T > struct is_member_object_pointer; (since C++11) Checks whether T is a non-static member object. Provides the member constant value which is equal to true, if T is a non-static member object type. Otherwise, value is equal to false. Template parameters T - a type to check Helper variable template template< class T > constexpr bool is_member_object_pointer_v = is_member_object_pointer<T>::va

template< class CharT, class Traits > basic_istream<CharT,Traits>& operator>>( basic_istream<CharT,Traits>& st, CharT& ch ); template< class Traits > basic_istream<char,Traits>& operator>>( basic_istream<char,Traits>& st, signed char& ch ); template< class Traits > basic_istream<char,Traits>& operator>>( basic_istream<char,Traits>& st, unsigned char& ch ); (1) template< class

Defined in header <type_traits> template< class T > struct is_arithmetic; (since C++11) If T is an arithmetic type (that is, an integral type or a floating-point type), provides the member constant value equal true. For any other type, value is false. Template parameters T - a type to check Helper variable template template< class T > constexpr bool is_arithmetic_v = is_arithmetic<T>::value; (since C++17) Inherited from std::inte

Defined in header <type_traits> template< class T > struct alignment_of; (since C++11) Provides the member constant value equal to the alignment requirement of the type T, as if obtained by an alignof expression. If T is an array type, returns the alignment requirements of the element type. If T is a reference type, returns the alignment requirements of the type referred to. If alignof(T) is not a valid expression, the behavior is undefined. Helper variable templat

Defined in header <cstdlib> void* realloc( void* ptr, std::size_t new_size ); Reallocates the given area of memory. It must be previously allocated by std::malloc(), std::calloc() or std::realloc() and not yet freed with std::free(), otherwise, the results are undefined. The reallocation is done by either: a) expanding or contracting the existing area pointed to by ptr, if possible. The contents of the area remain unchanged up to the lesser of the new and old sizes. If the

Defined in header <utility> template< class T > typename std::remove_reference<T>::type&& move( T&& t ); (since C++11) (until C++14) template< class T > constexpr typename std::remove_reference<T>::type&& move( T&& t ); (since C++14) std::move is used to indicate that an object t may be "moved from", i.e. allowing the efficient transfer of resources from t to another object. In particular, std::move produces an x