template< class T, class Container > void swap( queue<T,Container>& lhs, queue<T,Container>& rhs ); Specializes the std::swap algorithm for std::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: noexcept(noexcept(lhs.swap(rhs))) (since C++17) See

template< class T, class Container, class Alloc > struct uses_allocator<queue<T,Container>,Alloc> : std::uses_allocator<Container, Alloc>::type { }; (since C++11) Provides a transparent specialization of the std::uses_allocator type trait for std::queue: the container adaptor uses allocator if and only if the underlying container does. Inherited from std::integral_constant Member constants value [static] true (public static member constant) Mem

Program termination The following functions manage program termination and resource cleanup. Defined in header <cstdlib> abort causes abnormal program termination (without cleaning up) (function) exit causes normal program termination with cleaning up (function) quick_exit (C++11) causes quick program termination without completely cleaning up (function) _Exit (C++11) causes normal program termination without cleaning up (function) atexit registers a func

Defined in header <iostream> extern std::ostream cout; (1) extern std::wostream wcout; (2) The global objects std::cout and std::wcout control output to a stream buffer of implementation-defined type (derived from std::streambuf), associated with the standard C output stream stdout. These objects are guaranteed to be initialized during or before the first time an object of type std::ios_base::Init is constructed and are available for use in the constructors and destru

template< class T, class U > std::shared_ptr<T> static_pointer_cast( const std::shared_ptr<U>& r ); (1) (since C++11) template< class T, class U > std::shared_ptr<T> dynamic_pointer_cast( const std::shared_ptr<U>& r ); (2) (since C++11) template< class T, class U > std::shared_ptr<T> const_pointer_cast( const std::shared_ptr<U>& r ); (3) (since C++11) Creates a new instance of std::shared_ptr whose managed

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 <cwctype> std::wint_t towctrans( std::wint_t wc, std::wctrans_t desc ); Maps the wide character wc using the current C locale's LC_CTYPE mapping category identified by desc. Parameters ch - the wide character to map desc - the LC_CTYPE mapping, obtained from a call to std::wctrans Return value The mapped value of ch using the mapping identified by desc in LC_CTYPE facet of the current C locale. Example The following example demonstr

Defined in header <cwctype> std::wint_t towlower( std::wint_t ch ); Converts the given wide character to lowercase, if possible. Parameters ch - wide character to be converted Return value Lowercase version of ch or unmodified ch if no lowercase version is listed in the current C locale. Notes Only 1:1 character mapping can be performed by this function, e.g. the Greek uppercase letter 'Σ' has two lowercase forms, depending on the position in a word: 'σ' an

Defined in header <type_traits> template<class... B> struct disjunction; (1) (since C++17) Forms the logical disjunction of the type traits B... . The BaseCharacteristic of a specialization std::disjunction <B1, ..., BN> is the first Bi for which Bi::value != false, or if every Bi::value == false, the BaseCharacteristic is BN. If sizeof...(B) == 0, the BaseCharacteristic is std::false_type. Disjunction is short-circuiting: if there is a template type argument Bi