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

Defined in header <scoped_allocator> size_type max_size() const; (since C++11) Reports the maximum allocation size supported by the outer allocator, by calling std::allocator_traits<OuterAlloc>::max_size(outer_allocator()). Parameters (none). Return value The maximum allocation size for OuterAlloc. See also max_size returns the largest supported allocation size (public member function of std::allocator) max_size [static] returns the maximum object

This header was originally in the C standard library as <inttypes.h>. Provides conversions from C byte and wide strings to std::intmax_t and std::uintmax_t, overloads some math functions for std::intmax_t and provide C style input/output format macros for the types declared in <cstdint>. Includes <cstdint> Types imaxdiv_t (C++11) structure type, return of the std::imaxdiv function (typedef) Functions abs(std::intmax_t)imaxabs (C++11)(C++11) computes

int_type sputc( char_type ch ); Writes one character to the output sequence. If the output sequence write position is not available (the buffer is full), then calls overflow(ch). Parameters ch - character to write Return value The written character, converted to int_type with Traits::to_int_type(ch). on success. Traits::eof() (as returned by overflow()) on failure. Example #include <iostream> #include <sstream> int main() { std::ostringstream s;

template< class... Types > void swap( tuple<Types...>& lhs, tuple<Types...>& rhs ); (since C++11) Swaps the contents of lhs and rhs. Equivalent to lhs.swap(rhs). Parameters lhs, rhs - tuples whose contents to swap Return value (none). Exceptions noexcept specification: noexcept(noexcept(lhs.swap(rhs))) See also

Defined in header <type_traits> template< class T > struct is_lvalue_reference; (since C++11) Checks whether T is a lvalue reference type. Provides the member constant value which is equal to true, if T is a lvalue reference type. Otherwise, value is equal to false. Template parameters T - a type to check Helper variable template template< class T > constexpr bool is_lvalue_reference_v = is_lvalue_reference<T>::value; (since C++17)

Defined in header <atomic> template< class T > T kill_dependency( T y ); Informs the compiler that the dependency tree started by an std::memory_order_consume atomic load operation does not extend past the return value of std::kill_dependency; that is, the argument does not carry a dependency into the return value. This may be used to avoid unnecessary std::memory_order_acquire fences when the dependency chain leaves function scope (and the function does not have the

template <class Rep1, class Period1, class Rep2, class Period2> struct common_type<std::chrono::duration<Rep1, Period1>, std::chrono::duration<Rep2, Period2>> { typedef std::chrono::duration< typename std::common_type<Rep1, Rep2>::type, /*see note*/> type; }; (since C++11) Exposes the type named type, which is the common type of two std::chrono::durations. Note The period of the resulting duration is the greatest comm

Specifies that an instance of the type can be default-constructed in-place by a given allocator. Requirements The type T is DefaultInsertable into the Container X whose value_type is identical to T if, given. A an allocator type m an lvalue of type A p the pointer of type T* prepared by the container where X::allocator_type is identical to std::allocator_traits<A>::rebind_alloc<T>, the following expression is well-formed: std::allocator_traits<A>::construct(m,

Defined in header <locale> explicit ctype( std::size_t refs = 0 ); Creates a std::ctype facet and forwards the starting reference count refs to the base class constructor, locale::facet::facet(). Parameters refs - starting reference count