std::multiset::multiset(3)

NAME
std::multiset::multiset - std::multiset::multiset

Synopsis
   multiset(); (1)
   explicit multiset( const Compare& comp, (2)
   const Allocator& alloc = Allocator() );
   explicit multiset( const Allocator& alloc ); (3) (since C++11)
   template< class InputIt >
   multiset( InputIt first, InputIt last, (4)
   const Compare& comp = Compare(),
   const Allocator& alloc = Allocator() );
   template< class InputIt >
   multiset( InputIt first, InputIt last, (5) (since C++14)
   const Allocator& alloc );
   multiset( const multiset& other ); (6)
   multiset( const multiset& other, const Allocator& alloc ); (7) (since C++11)
   multiset( multiset&& other ); (8) (since C++11)
   multiset( multiset&& other, const Allocator& alloc ); (9) (since C++11)
   multiset( std::initializer_list<value_type> init,
   const Compare& comp = Compare(), (10) (since C++11)
   const Allocator& alloc = Allocator() );
   multiset( std::initializer_list<value_type> init, (11) (since C++14)
   const Allocator& );
   Constructs new container from a variety of data sources and optionally using user
   supplied allocator alloc or comparison function object comp.
   1-3) Constructs an empty container.
   4-5) Constructs the container with the contents of the range [first, last).
   6-7) Copy constructor. Constructs the container with the copy of the contents of
   other.
   If alloc is not provided, allocator is obtained by calling (since
   std::allocator_traits<allocator_type>::select_on_container_copy_construction( C++11)
   other.get_allocator()).
   The template parameter Allocator is only deduced from the first argument (since
   while used in class template argument deduction. C++23)
   8-9) Move constructor. Constructs the container with the contents of other using
   move semantics. If alloc is not provided, allocator is obtained by move-construction
   from the allocator belonging to other.
   The template parameter Allocator is only deduced from the first (since C++23)
   argument while used in class template argument deduction.
   10-11) Constructs the container with the contents of the initializer list init.

Parameters
   alloc - allocator to use for all memory allocations of this container
   comp - comparison function object to use for all comparisons of keys
   first, last - the range to copy the elements from
   other - another container to be used as source to initialize the elements of
                 the container with
   init - initializer list to initialize the elements of the container with

Type requirements
   -
   InputIt must meet the requirements of LegacyInputIterator.
   -
   Compare must meet the requirements of Compare.
   -
   Allocator must meet the requirements of Allocator.

Complexity
   1-3) Constant
   4-5) N log(N) where N = std::distance(first, last) in general, linear in N if the
   range is already sorted by value_comp().
   6-7) Linear in size of other
   8-9) Constant. If alloc is given and alloc != other.get_allocator(), then linear.
   10-11) N log(N) where N = init.size() in general, linear in N if init is already
   sorted by value_comp().

Exceptions
   Calls to Allocator::allocate may throw.

Notes
   After container move construction (overload (8-9)), references, pointers, and
   iterators (other than the end iterator) to other remain valid, but refer to elements
   that are now in *this. The current standard makes this guarantee via the blanket
   statement in [container.requirements.general]/12, and a more direct guarantee is
   under consideration via LWG 2321.
   Although not formally required until C++23, some implementations has already put the
   template parameter Allocator into non-deduced contexts in earlier modes.

Example
// Run this code
 #include <iostream>
 #include <string_view>
 #include <set>
 void print(const std::string_view name, const std::multiset<int>& ms)
 {
         std::cout << name << ": ";
         for(auto element: ms)
                 std::cout << element << " ";
         std::cout << '\n';
 }
 int main()
 {
         // (1) Default constructor
         std::multiset<int> a;
         a.insert(4);
         a.insert(3);
         a.insert(2);
         a.insert(1);
         print("a", a);
         // (4) Iterator constructor
         std::multiset<int> b(a.begin(), a.find(3));
         print("b", b);
         // (6) Copy constructor
         std::multiset<int> c(a);
         print("c", c);
         // (8) Move constructor
         std::multiset<int> d(std::move(a));
         print("d", d);
         // (10) Initializer list constructor
         std::multiset<int> e {3,2,1,2,4,7,3};
         print("e", e);
 }

Output:
 a: 1 2 3 4
 b: 1 2
 c: 1 2 3 4
 d: 1 2 3 4
 e: 1 2 2 3 3 4 7
  Defect reports
   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.
      DR Applied to Behavior as published Correct behavior
   LWG 2193 C++11 the default constructor is explicit made non-explicit

See also
   operator= assigns values to the container
             (public member function)