void swap( set& 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 an unq

protected: virtual int_type underflow() Reads the next character from the get area of the buffer. Specifically: 1) If the input sequence has a read position available (egptr() > gptr()), returns Traits::to_int_type(*gptr()) 2) Otherwise, if pptr() > egptr() (some characters were inserted into the stream since the last time overflow() changed egptr()) then extends the end of the get area to include the most recently inserted characters, by changing egptr() to equal pptr(), and t

Defined in header <locale> public: result out( StateT& state, const InternT* from, const InternT* from_end, const InternT*& from_next, ExternT* to, ExternT* to_end, ExternT*& to_next ) const; (1) protected: virtual result do_out( StateT& state, const InternT* from, const InternT* from_end, const InternT*& from_next,

void notify_one(); (since C++11) If any threads are waiting on *this, calling notify_one unblocks one of the waiting threads. Parameters (none). Return value (none). Exceptions noexcept specification: noexcept Notes The effects of notify_one()/notify_all() and wait()/wait_for()/wait_until() take place in a single total order, so it's impossible for notify_one() to, for example, be delayed and unblock a thread that started waiting just after the call to notify_one() was mad

std::basic_filebuf<CharT, Traits>* close(); If a put area exist (e.g. file was opened for writing), first calls overflow(Traits::eof()) to write all pending output to the file, including any unshift sequences. If the most recently called function, out of underflow(), overflow(), seekpos(), and seekoff(), was overflow(), then calls std::codecvt::unshift(), perhaps multiple times, to determine the unshift sequence according to the imbued locale, and writes that sequence to file with

Defined in header <algorithm> template< class InputIt1, class InputIt2, class OutputIt > OutputIt merge( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt d_first ); (1) template< class InputIt1, class InputIt2, class OutputIt, class Compare> OutputIt merge( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt d_first, Compare comp ); (2) Merges t

template< class Iterator1, class Iterator2 > auto operator-( const move_iterator<Iterator1>& lhs, const move_iterator<Iterator2>& rhs ) -> decltype(lhs.base() - rhs.base()); (since C++11) Returns the distance between two iterator adaptors. Parameters lhs, rhs - iterator adaptors to compute the difference of Return value lhs.base() - rhs.base(). Example

pointer release(); (since C++11) Releases the ownership of the managed object if any. get() returns nullptr after the call. Parameters (none). Return value Pointer to the managed object or nullptr if there was no managed object, i.e. the value which would be returned by get() before the call. Exceptions noexcept specification: noexcept Example #include <memory> #include <iostream> #include <cassert> struct Foo { Foo() { std::cout << "Foo\n";

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

Defined in header <memory> template< class T > T* undeclare_reachable( T* p ); (since C++11) Removes the reachable status of the object, referenced by the pointer p, if it was previously set by std::declare_reachable. If the object was declared reachable multiple times, equal number of calls to undeclare_reachable would be needed to remove this status. Once the object is not declared reachable and has no pointers referencing it, it may be reclaimed by garbage collecto