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<

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

Defined in header <functional> template< class F, class... Args > /*unspecified*/ bind( F&& f, Args&&... args ); (1) (since C++11) template< class R, class F, class... Args > /*unspecified*/ bind( F&& f, Args&&... args ); (2) (since C++11) The function template bind generates a forwarding call wrapper for f. Calling this wrapper is equivalent to invoking f with some of its arguments bound to args. Parameters f - Call

Defined in header <utility> template< class T > typename std::add_rvalue_reference<T>::type declval(); (since C++11) Converts any type T to a reference type, making it possible to use member functions in decltype expressions without the need to go through constructors. declval is commonly used in templates where acceptable template parameters may have no constructor in common, but have the same member function whose return type is needed. Note that because no de

Defined in header <random> template< class UIntType, size_t w, size_t s, size_t r > class subtract_with_carry_engine; (since C++11) subtract_with_carry_engine is a random number engine that uses subtract with carry algorithm. The following typedefs define the random number engine with two commonly used parameter sets: Defined in header <random> Type Definition ranlux24_base std::subtract_with_carry_engine<std::uint_fast32_t, 24, 10, 24>

reference back(); const_reference back() const; Returns reference to the last element in the queue. This is the most recently pushed element. Effectively calls c.back(). Parameters (none). Return value reference to the last element. Complexity Constant. See also front access the first element (public member function) push inserts element at the end (public member function)

template< class... Args > void emplace( Args&&... args ); (since C++11) Pushes new element to the end of the queue. The element is constructed in-place, i.e. no copy or move operations are performed. The constructor of the element is called with exactly the same arguments as supplied to the function. Effectively calls c.emplace_back(std::forward<Args>(args)...). Parameters args - arguments to forward to the constructor of the element Return value (none)

reference front(); const_reference front() const; Returns reference to the first element in the queue. This element will be the first element to be removed on a call to pop(). Effectively calls c.front(). Parameters (none). Return value Reference to the first element. Complexity Constant. See also back access the last element (public member function) pop removes the first element (public member function)

void push( const T& value ); void push( T&& value ); (since C++11) Pushes the given element value to the end of the queue. 1) Effectively calls c.push_back(value) 2) Effectively calls c.push_back(std::move(value)) Parameters value - the value of the element to push Return value (none). Complexity Equal to the complexity of Container::push_back. See also emplace (C++11) constructs element in-place at the end (public member function) pop

template< class T, class Container, class Compare > void swap( priority_queue<T,Container,Compare>& lhs, priority_queue<T,Container,Compare>& rhs ); Specializes the std::swap algorithm for std::priority_queue. Swaps the contents of lhs and rhs. Calls lhs.swap(rhs). Parameters lhs, rhs - containers whose contents to swap Return value (none). Complexity Same as swapping the underlying container. Exceptions noexcept specification: