Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      std::map<Key,T,Compare,Allocator>::map

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

      [edit template]
       
       
       
      std::map
      Member functions
      map::map
                   
      Non-member functions
      (until C++20)(until C++20)(until C++20)(until C++20)(until C++20)
      Deduction guides(C++17)
       
      (1)
      map();
      		(until C++11)
      map(): map(Compare()){}
      		(since C++11)
      (constexpr since C++26)
      explicit map(const Compare& comp,
                   const Allocator& alloc= Allocator());
      		 (2)(constexpr since C++26)
      explicit map(const Allocator& alloc);
      		 (3)(since C++11)
      (constexpr since C++26)
      template<class InputIt>

      map( InputIt first, InputIt last,
           const Compare& comp= Compare(),

           const Allocator& alloc= Allocator());
      		 (4)(constexpr since C++26)
      template<class InputIt>

      map( InputIt first, InputIt last,
           const Allocator& alloc)

         : map(first, last, Compare(), alloc){}
      		 (5)(since C++14)
      (constexpr since C++26)
      map(const map& other);
      		 (6)(constexpr since C++26)
      map(const map& other,const Allocator& alloc);
      		 (7)(since C++11)
      (constexpr since C++26)
      map( map&& other);
      		 (8)(since C++11)
      (constexpr since C++26)
      map( map&& other,const Allocator& alloc);
      		 (9)(since C++11)
      (constexpr since C++26)
      map(std::initializer_list<value_type> init,

           const Compare& comp= Compare(),

           const Allocator& alloc= Allocator());
      		 (10)(since C++11)
      (constexpr since C++26)
      map(std::initializer_list<value_type> init,

           const Allocator& alloc)

         : map(init, Compare(), alloc){}
      		 (11)(since C++14)
      (constexpr since C++26)
      template<container-compatible-range<value_type> R>

      map(std::from_range_t, R&& rg,
           const Compare& comp= Compare(),

           const Allocator& alloc= Allocator());
      		 (12)(since C++23)
      (constexpr since C++26)
      template<container-compatible-range<value_type> R>

      map(std::from_range_t, R&& rg,
           const Allocator& alloc)

         : map(std::from_range,std::forward<R>(rg), Compare(), alloc){}
      		 (13)(since C++23)
      (constexpr since C++26)

      Constructs new container from a variety of data sources and optionally using user supplied allocatoralloc or comparison function objectcomp.

      1-3) Constructs an empty container.
      4,5) Constructs the container with the contents of the range[first, last).
      If[first, last) is not avalid range, the behavior is undefined.
      6,7) Constructs the container with the copy of the contents ofother.

      Ifalloc is not provided, allocator is obtained by callingstd::allocator_traits<allocator_type>::
          select_on_container_copy_construction(other.get_allocator())      .

      		(since C++11)

      Duringclass template argument deduction, only the first argument contributes to the deduction of the container'sAllocator template parameter.

      		(since C++23)
      8,9) Constructs the container with the contents ofother using move semantics. Ifalloc is not provided, allocator is obtained by move-construction from the allocator belonging toother.

      Duringclass template argument deduction, only the first argument contributes to the deduction of the container'sAllocator template parameter.

      		(since C++23)
      10,11) Constructs the container with the contents of the initializer listinit.
      12,13) Constructs the container with the contents ofrg.

      Contents

      [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 pair of iterators defining the sourcerange of elements to copy
      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
      rg - acontainer compatible range, that is, aninput_range whose elements are convertible tovalue_type
      Type requirements
      -
      InputIt must meet the requirements ofLegacyInputIterator.
      -
      Compare must meet the requirements ofCompare.
      -
      Allocator must meet the requirements ofAllocator.

      [edit]Complexity

      1-3) Constant.
      4,5)\(\scriptsize N \cdot log(N)\)N·log(N) where\(\scriptsize N\)N isstd::distance(first, last) in general, linear in\(\scriptsize N\)N if[first, last) is already sorted byvalue_comp().
      6,7) Linear in size ofother.
      8,9) Constant. Ifalloc is given andalloc!= other.get_allocator(), then linear.
      10,11)\(\scriptsize N \cdot log(N)\)N·log(N) where\(\scriptsize N\)N isinit.size() in general, linear in\(\scriptsize N\)N ifinit is already sorted byvalue_comp().
      12,13)\(\scriptsize N \cdot log(N)\)N·log(N) where\(\scriptsize N\)N isranges::distance(rg) in general, linear in\(\scriptsize N\)N ifrg is already sorted byvalue_comp().

      [edit]Exceptions

      Calls toAllocator::allocate may throw.

      [edit]Notes

      After container move construction (overload(8,9)), references, pointers, and iterators (other than the end iterator) toother remain valid, but refer to elements that are now in*this. The current standard makes this guarantee via the blanket statement in[container.reqmts]/67, and a more direct guarantee is under consideration viaLWG issue 2321.

      If multiple elements in the range have keys that compare equivalent, it is unspecified which element is inserted (pendingLWG2844).

      Although not formally required until C++23, some implementations has already put the template parameterAllocator intonon-deduced contexts in earlier modes.

      Feature-test macroValueStdFeature
      __cpp_lib_containers_ranges202202L(C++23)Ranges-aware construction and insertion; overloads(12,13)

      [edit]Example

      Run this code
      #include <iomanip>#include <iostream>#include <map>#include <string> template<typename Key,typename Value,typename Cmp>std::ostream& operator<<(std::ostream& os,conststd::map<Key, Value, Cmp>& map){    os<<"{ ";for(auto comma{map.size()};constauto& p: map)        os<<'\''<< p.first<<"' is "<< p.second<<(--comma?", ":" ");return os<<"}\n";} struct Point{double x, y; friendstd::ostream& operator<<(std::ostream& os, Point pt){return os<<'('<< pt.x<<", "<< pt.y<<')';}}; struct PointCmp{bool operator()(const Point& lhs,const Point& rhs)const{return lhs.x< rhs.x;// NB: y is intentionally ignored}}; int main(){// (1) Default constructorstd::map<std::string,int> map1;    map1["something"]=69;    map1["anything"]=199;    map1["that thing"]=50;std::cout<<"map1 = "<< map1; // (4) Range constructorstd::map<std::string,int> iter(map1.find("anything"), map1.end());std::cout<<"\niter = "<< iter;std::cout<<"map1 = "<< map1; // (6) Copy constructorstd::map<std::string,int> copied(map1);std::cout<<"\ncopied = "<< copied;std::cout<<"map1 = "<< map1; // (8) Move constructorstd::map<std::string,int> moved{std::move(map1)};std::cout<<"\nmoved = "<< moved;std::cout<<"map1 = "<< map1; // (10) Initializer list constructorconststd::map<std::string,int> init{{"this",100},{"can",100},{"be",100},{"const",100}};std::cout<<"\ninit = "<< init; std::cout<<"\nCustom Key class option 1:\n";// Use a comparison structstd::map<Point,double, PointCmp> mag={{{5,-12},13},{{3,4},5},{{-8,-15},17}};std::cout<<"mag = "<< mag<<'\n'; std::cout<<"Custom Key class option 2:\n";// Use a comparison lambda// This lambda sorts points according to their magnitudes, where// these magnitudes are taken from the local variable mag.auto cmpLambda=[&mag](const Point& lhs,const Point& rhs){return mag[lhs]< mag[rhs];}; // You could also use a lambda that is not dependent on local variables, like this:// auto cmpLambda = [](const Point& lhs, const Point& rhs){ return lhs.y < rhs.y; };std::map<Point,double, decltype(cmpLambda)> magy(cmpLambda); // Various ways of inserting elements:    magy.insert(std::pair<Point,double>({5,-12},13));    magy.insert({{3,4},5});    magy.insert({Point{-8.0,-15.0},17});std::cout<<"magy = "<< magy<<'\n'; std::cout<<"Construction from a range:\n";using PS=std::pair<conststd::string,int>;constauto rg={PS{"one",1},{"one",101},{"two",2},{"three",3}};#if __cpp_lib_containers_rangesstd::map<std::string,int> nums(std::from_range, rg);// overload (12)#elsestd::map<std::string,int> nums(rg.begin(), rg.end());// fallback to (4)#endifstd::cout<<"nums = "<< nums<<'\n';}

      Output:

      map1 = { 'anything' is 199, 'something' is 69, 'that thing' is 50 } iter = { 'anything' is 199, 'something' is 69, 'that thing' is 50 }map1 = { 'anything' is 199, 'something' is 69, 'that thing' is 50 } copied = { 'anything' is 199, 'something' is 69, 'that thing' is 50 }map1 = { 'anything' is 199, 'something' is 69, 'that thing' is 50 } moved = { 'anything' is 199, 'something' is 69, 'that thing' is 50 }map1 = { } init = { 'be' is 100, 'can' is 100, 'const' is 100, 'this' is 100 } Custom Key class option 1:mag = { '(-8, -15)' is 17, '(3, 4)' is 5, '(5, -12)' is 13 } Custom Key class option 2:magy = { '(3, 4)' is 5, '(5, -12)' is 13, '(-8, -15)' is 17 } Construction from a range:nums = { 'one' is 1, 'three' is 3, 'two' is 2 }

      [edit]Defect reports

      The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

      DRApplied toBehavior as publishedCorrect behavior
      LWG 2076C++11overload(4) conditionally requiredKeyandT to beCopyInsertable into*thisnot required
      LWG 2193C++11the default constructor was explicitmade non-explicit

      [edit]See also

      assigns values to the container
      (public member function)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/container/map/map&oldid=135939"
      [8]ページ先頭
      ©2009-2025 Movatter.jp