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:

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

template< class Clock, class Duration > bool try_lock_shared_until( const std::chrono::time_point<Clock,Duration>& timeout_time ); (since C++14) Tries to lock the mutex in shared mode. 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_shared(). The clock tied to timeout_time is use