template< class... Args > void emplace( Args&&... args ); (since C++11) Pushes new element to the priority 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)...); std::push_heap(c.begin(), c.end(), comp); Parameters args - arguments to forward to the constructor

static bool sync_with_stdio( bool sync = true ); Sets whether the standard C++ streams are synchronized to the standard C streams after each input/output operation. The standard C++ streams are the following: std::cin, std::cout, std::cerr, std::clog, std::wcin, std::wcout, std::wcerr and std::wclog. The standard C streams are the following: stdin, stdout and stderr. For a standard stream str, synchronized with the C stream f, the following pairs of functions have identical effect: 1)

void swap( multiset& other ); Exchanges the contents of the container with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated. The Pred objects must be Swappable, and they are exchanged using unqualified call to non-member swap. If std::allocator_traits<allocator_type>::propagate_on_container_swap::value is true, then the allocators are exchanged using a

static int_type eof(); (until C++11) static constexpr int_type eof(); (since C++11) Returns a value not equivalent to any value of type char_type. Parameters (none). Return value A value not equivalent to any value of type char_type. Exceptions (none) (until C++11) noexcept specification: noexcept (since C++11) Complexity Constant. See also not_eof [static] checks whether a character is eof value (public static member function)

reference at( size_type pos ); (since C++11) const_reference at( size_type pos ) const; (since C++11) (until C++14) constexpr const_reference at( size_type pos ) const; (since C++14) Returns a reference to the element at specified location pos, with bounds checking. If pos not within the range of the container, an exception of type std::out_of_range is thrown. Parameters pos - position of the element to return Return value Reference to the requested eleme

Defined in header <regex> regex_error(std::regex_constants::error_type ecode); (since C++11) Constructs a regex_error with a given ecode of type std::regex_constants::error_type . See Also error_type (C++11) describes different types of matching errors (typedef)

template< class CharT, class Traits, class ResultType > std::basic_ostream<CharT,Traits>& operator<<( std::basic_ostream<CharT,Traits>& ost, const piecewise_linear_distribution<ResultType>& d ); (1) template< class CharT, class Traits, class ResultType > std::basic_istream<CharT,Traits>& operator>>( std::basic_istream<CharT,Traits>& ist,

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)