Defined in header <mutex> template< class Mutex > class lock_guard; (since C++11) (until C++17) template< class... MutexTypes > class lock_guard; (since C++17) The class lock_guard is a mutex wrapper that provides a convenient RAII-style mechanism for owning a mutex or several mutexes (since C++17) for the duration of a scoped block. When a lock_guard object is created, it attempts to take ownership of the mutex it is given. When control leaves the scope i

Defined in header <cmath> bool isless( float x, float y ); (1) (since C++11) bool isless( double x, double y ); (2) (since C++11) bool isless( long double x, long double y ); (3) (since C++11) bool isless( Arithmetic x, Arithmetic y ); (4) (since C++11) 1-3) Determines if the floating point number x is less than the floating-point number y, without setting floating-point exceptions. 4) A set of overloads or a function template for all combinations of arg

Defined in header <clocale> struct lconv; The class std::lconv contains numeric and monetary formatting rules as defined by a C locale. Objects of this struct may be obtained with std::localeconv. The members of std::lconv are values of type char and of type char*. Each char* member except decimal_point may be pointing at a null character (that is, at an empty C-string). The members of type char are all non-negative numbers, any of which may be CHAR_MAX if the corresponding

Defined in header <functional> template< class T > struct plus; (until C++14) template< class T = void > struct plus; (since C++14) Function object for performing addition. Effectively calls operator+ on two instances of type T. Specializations The standard library provides a specialization of std::plus when T is not specified, which leaves the parameter types and return type to be deduced. plus<void> function object implementing x + y deduci

explicit student_t_distribution( RealType n = 1 ); (1) (since C++11) explicit student_t_distribution( const param_type& params ); (2) (since C++11) Constructs new distribution object. The first version uses n as the distribution parameter, the second version uses params as the distribution parameter. Parameters n - the n distribution parameter (degrees of freedom) params - the distribution parameter set

Defined in header <functional> template<> class greater<void>; (since C++14) std::greater<> is a specialization of std::greater with parameter and return type deduced. Member types Member type Definition is_transparent /* unspecified */ Member functions operator() tests if the lhs compares greater than rhs (public member function) std::greater<>::operator() template< class T, class U> constexpr auto operator()( T&am

(See also type for type system overview). Basic types Fundamental types defined by the language Additional basic types and macros Defined in header <cstddef> size_t unsigned integer type returned by the sizeof operator (typedef) ptrdiff_t signed integer type returned when subtracting two pointers (typedef) nullptr_t (C++11) the type of the null pointer literal nullptr (typedef) NULL implementation-defined null pointer constant (macro constant) max_ali

void swap( basic_istringstream& other ); (since C++11) Exchanges the state of the stream with those of other. This is done by callingbasic_istream<CharT, Traits>::swap(other) and rdbuf()->swap(*other.rdbuf()). Parameters other - stream to exchange the state with Return value (none). Example See also operator= (C++11) moves the string stream (public member function) swap (C++11) swaps two basic_stringbuf objects (public member function of st

void pop_front(); Removes the first element of the container. References and iterators to the erased element are invalidated. Parameters (none). Return value (none). Complexity Constant. Exceptions Does not throw. See also pop_back removes the last element (public member function) push_front inserts an element to the beginning (public member function)

template< class Key, class T, class Compare, class Alloc > bool operator==( const map<Key,T,Compare,Alloc>& lhs, const map<Key,T,Compare,Alloc>& rhs ); (1) template< class Key, class T, class Compare, class Alloc > bool operator!=( const map<Key,T,Compare,Alloc>& lhs, const map<Key,T,Compare,Alloc>& rhs ); (2) template< class Key, class T, class Compare, class Alloc > bool operator<( cons