##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::multimap::multimap

From cppreference.com
< cpp‎ | container‎ | multimap

[edit template]

explicit multimap( const Compare& comp = Compare(), const Allocator& alloc = Allocator() ); | (1) |
explicit multimap( const Allocator& alloc ); | (1) | (since C++11)
| (2) |
template< class InputIt > multimap( InputIt first, InputIt last, const Compare& comp = Compare(), const Allocator& alloc = Allocator() ); |  |
template< class InputIt > multimap( InputIt first, InputIt last, const Allocator& alloc = Allocator() ); |  | (since C++14)
multimap( const multimap& other ); | (3) |
multimap( const multimap& other, const Allocator& alloc ); | (3) | (since C++11)
multimap( multimap&& other ); | (4) | (since C++11)
multimap( multimap&& other, const Allocator& alloc ); | (4) | (since C++11)
| (5) |
multimap( std::initializer_list<value_type> init, const Compare& comp = Compare(), const Allocator& alloc = Allocator() ); |  | (since C++11)
multimap( std::initializer_list<value_type> init, const Allocator& alloc = Allocator() ); |  | (since C++14)

Constructs new container from a variety of data sources and optionally using user supplied allocator `alloc` or comparison function object `comp`.

1) Default constructor. Constructs empty container.

2) Constructs the container with the contents of the range `[first, last)`.

3) Copy constructor. Constructs the container with the copy of the contents of `other`. If `alloc` is not provided, allocator is obtained by calling std::allocator_traits<allocator_type>::select_on_copy_construction(other).

4) 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`.

5) Constructs the container with the contents of the initializer list `init`.

### [edit] 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 `InputIterator`.
- `Compare` must meet the requirements of `Compare`.
- `Allocator` must meet the requirements of `Allocator`.

### [edit] Complexity

1) Constant

2) N log(N) where N = std::distance(first, last) in general, linear in `N` if the range is already sorted by `value_comp()`.

3) Linear in size of `other`

4) Constant. If `alloc` is given and alloc != other.get_allocator(), then linear.

5) N log(N) where N = init.size()) in general, linear in `N` if `init` is already sorted by `value_comp()`.

### [edit] Example

Run this code

    #include <iostream>
    #include <functional>
    #include <map>

    template<typename Key, typename T, typename Compare, typename Allocator>
    std::ostream& operator<<(std::ostream& stream, const std::map<Key, T, Compare, Allocator>& map);
    template<typename T, typename Compare, typename Allocator>
    std::ostream& operator<<(std::ostream& stream, const std::map<std::string, T, Compare, Allocator>& map);
    template<typename Key, typename Compare, typename Allocator>
    std::ostream& operator<<(std::ostream& stream, const std::map<Key, std::string, Compare, Allocator>& map);
    template<typename Compare, typename Allocator>
    std::ostream& operator<<(std::ostream& stream, const std::map<std::string, std::string, Compare, Allocator>& map);

    int main()
    {
      typedef std::string Key;
      typedef int Mapped;

      // (1) Default constructor
      std::map<Key, Mapped> map;
      map["something"] = 69;
      map["anything"] = 199;
      map["that thing"] = 50;
      std::cerr << std::string(80, '-') << std::endl;
      std::cerr << "map = " << map << std::endl;

      // (2) Iterator constructor
      std::map<Key, Mapped> iter(map.find("anything"), map.end());
      std::cerr << std::string(80, '-') << std::endl;
      std::cerr << "iter = " << iter << std::endl;
      std::cerr << "map = " << map << std::endl;

      // (3) Copy constructor
      std::map<Key, Mapped> copy(map);
      std::cerr << std::string(80, '-') << std::endl;
      std::cerr << "copy = " << copy << std::endl;
      std::cerr << "map = " << map << std::endl;

      // (4) Move constructor
      std::map<Key, Mapped> moved(std::move(map));
      std::cerr << std::string(80, '-') << std::endl;
      std::cerr << "moved = " << copy << std::endl;
      std::cerr << "map = " << map << std::endl;

      // (5) Initializer list constructor
      const std::map<Key, Mapped> init {
        {"this", 100},
        {"can", 100},
        {"be", 100},
        {"const", 100},
      };
      std::cerr << std::string(80, '-') << std::endl;
      std::cerr << "init = " << init << std::endl;
    }

    // A printer for unordered maps
    template<typename Key, typename T, typename Compare, typename Allocator>
    std::ostream& operator<<(std::ostream& stream,
        const std::map<Key, T, Compare, Allocator>& map) {
      stream << '{';
      char comma[3] = {'\0', ' ', '\0'};
      for (const auto& pair : map) {
        stream << comma << pair.first << ':' << pair.second;
        comma[0] = ',';
      }
      stream << '}';
      return stream;
    }

    // A specialization for Key strings
    template<typename T, typename Compare, typename Allocator>
    std::ostream& operator<<(std::ostream& stream,
        const std::map<std::string, T, Compare, Allocator>& map) {
      stream << '{';
      char comma[3] = {'\0', ' ', '\0'};
      for (const auto& pair : map) {
        stream << comma << '"' << pair.first << "\":" << pair.second;
        comma[0] = ',';
      }
      stream << '}';
      return stream;
    }

    // A printer for unordered maps
    template<typename Key, typename Compare, typename Allocator>
    std::ostream& operator<<(std::ostream& stream,
        const std::map<Key, std::string, Compare, Allocator>& map) {
      stream << '{';
      char comma[3] = {'\0', ' ', '\0'};
      for (const auto& pair : map) {
        stream << comma << pair.first << ":\"" << pair.second << '"';
        comma[0] = ',';
      }
      stream << '}';
      return stream;
    }

    // A specialization for Key and Mapped strings
    template<typename Compare, typename Allocator>
    std::ostream& operator<<(std::ostream& stream,
        const std::map<std::string, std::string, Compare, Allocator>& map) {
      stream << '{';
      char comma[3] = {'\0', ' ', '\0'};
      for (const auto& pair : map) {
        stream << comma << '"' << pair.first << "\":\"" << pair.second << '"';
        comma[0] = ',';
      }
      stream << '}';
      return stream;
    }

Output:

    --------------------------------------------------------------------------------
    map = {"anything":199, "something":69, "that thing":50}
    --------------------------------------------------------------------------------
    iter = {"anything":199, "something":69, "that thing":50}
    map = {"anything":199, "something":69, "that thing":50}
    --------------------------------------------------------------------------------
    copy = {"anything":199, "something":69, "that thing":50}
    map = {"anything":199, "something":69, "that thing":50}
    --------------------------------------------------------------------------------
    moved = {"anything":199, "something":69, "that thing":50}
    map = {}
    --------------------------------------------------------------------------------
    init = {"be":100, "can":100, "const":100, "this":100}

### [edit] See also

operator= | assigns values to the container (public member function) [edit]

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/container/multimap/multimap&oldid=50589"