std::flat_multimap::コンストラクタ

// ____要素数ゼロのflat_multimapを構築____

flat_multimap() : flat_multimap(key_compare()) { } // (1) C++23

explicit flat_multimap(const key_compare& comp) // (2) C++23
  : c(), compare(comp) { }

template<class Allocator>
explicit flat_multimap(const Allocator& a); // (3) C++23

template<class Allocator>
flat_multimap(const key_compare& comp, const Allocator& a); // (4) C++23

// ____アロケータを伴うコピー＆ムーブコンストラクタ____

 template<class Allocator>
 flat_multimap(const flat_multimap& x, const Allocator& a); // (5) C++26

 template<class Allocator>
 flat_multimap(flat_multimap&& x, const Allocator& a); // (6) C++26

// ____key_container_typeとmapped_container_typeから構築____

flat_multimap(key_container_type key_cont, mapped_container_type mapped_cont,
              const key_compare& comp = key_compare()); // (7) C++23

template<class Allocator>
flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
              const Allocator& a); // (8) C++23

template<class Allocator>
flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
              const key_compare& comp, const Allocator& a); // (9) C++23

// ____key_container_typeとmapped_container_type（共にソート済み）から構築____

flat_multimap(sorted_equivalent_t, key_container_type key_cont, mapped_container_type mapped_cont,
              const key_compare& comp = key_compare()); // (10) C++23

template<class Allocator>
flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
              const mapped_container_type& mapped_cont, const Allocator& a); // (11) C++23

template<class Allocator>
flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
              const mapped_container_type& mapped_cont,
              const key_compare& comp, const Allocator& a); // (12) C++23

// ____イテレータから構築____

template<class InputIterator>
flat_multimap(InputIterator first, InputIterator last, const key_compare& comp = key_compare()) // (13) C++23
  : c(), compare(comp) { insert(first, last); }

template<class InputIterator, class Allocator>
flat_multimap(InputIterator first, InputIterator last, const Allocator& a); // (14) C++23

template<class InputIterator, class Allocator>
flat_multimap(InputIterator first, InputIterator last,
              const key_compare& comp, const Allocator& a); // (15) C++23

// ____イテレータ（ソート済み）から構築____

template<class InputIterator>
flat_multimap(sorted_equivalent_t s, InputIterator first, InputIterator last,
              const key_compare& comp = key_compare()) // (16) C++23
  : c(), compare(comp) { insert(s, first, last); }

template<class InputIterator, class Allocator>
flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last, const Allocator& a); // (17) C++23

template<class InputIterator, class Allocator>
flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
              const key_compare& comp, const Allocator& a); // (18) C++23

// ____Rangeから構築____

template<container-compatible-range<value_type> R>
flat_multimap(from_range_t fr, R&& rg) // (19) C++23
  : flat_multimap(fr, forward<R>(rg), key_compare()) { }

template<container-compatible-range<value_type> R>
flat_multimap(from_range_t, R&& rg, const key_compare& comp) // (20) C++23
  : flat_multimap(comp) { insert_range(forward<R>(rg)); }

template<container-compatible-range<value_type> R, class Allocator>
flat_multimap(from_range_t, R&& rg, const Allocator& a); // (21) C++23

template<container-compatible-range<value_type> R, class Allocator>
flat_multimap(from_range_t, R&& rg, const key_compare& comp, const Allocator& a); // (22) C++23

// ____initializer_listから構築____

flat_multimap(initializer_list<value_type> il, const key_compare& comp = key_compare()) // (23) C++23
  : flat_multimap(il.begin(), il.end(), comp) { }

template<class Allocator>
flat_multimap(initializer_list<value_type> il, const Allocator& a); // (24) C++23

template<class Allocator>
flat_multimap(initializer_list<value_type> il, const key_compare& comp, const Allocator& a); // (25) C++23

// ____initializer_list（ソート済み）から構築____

flat_multimap(sorted_equivalent_t s, initializer_list<value_type> il,
              const key_compare& comp = key_compare()) // (26) C++23
  : flat_multimap(s, il.begin(), il.end(), comp) { }

template<class Allocator>
flat_multimap(sorted_equivalent_t, initializer_list<value_type> il, const Allocator& a); // (27) C++23

template<class Allocator>
flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
              const key_compare& comp, const Allocator& a); // (28) C++23

概要

flat_multimapオブジェクトを次に示す通りの要素で初期化する。

効果

(1) : デフォルトコンストラクタ。デフォルトの key_compare を作成し、要素を持たない空の flat_multimap オブジェクトを構築する。
(2) : key_compare を受け取り、要素を持たない空の flat_multimap オブジェクトを構築する。
(3) : アロケータを受け取り、要素を持たない空の flat_multimap オブジェクトを構築する。
(4) : key_compare とアロケータを受け取り、要素を持たない空の flat_multimap オブジェクトを構築する。
(5) : アロケータを受け取り、flat_multimap オブジェクトをコピー構築する。
(6) : アロケータを受け取り、flat_multimap オブジェクトをムーブ構築する。
(7) : key_container_type と mapped_container_type から flat_multimap オブジェクトを構築する。構築に際し、value_compare に基づきソートされる。
(8) : アロケータを受け取り、key_container_type と mapped_container_type から flat_multimap オブジェクトを構築する。構築に際し、value_compare に基づきソートされる。
(9) : key_compare とアロケータを受け取り、key_container_type と mapped_container_type から flat_multimap オブジェクトを構築する。構築に際し、value_compare に基づきソートされる。
(10) : key_container_type と mapped_container_type（共にソート済み）から flat_multimap オブジェクトを構築する。
(11) : アロケータを受け取り、key_container_type と mapped_container_type（共にソート済み）から flat_multimap オブジェクトを構築する。
(12) : key_compare とアロケータを受け取り、key_container_type と mapped_container_type（共にソート済み）から flat_multimap オブジェクトを構築する。
(13) : イテレータから flat_multimap オブジェクトを構築する。構築には insert() が用いられる。
(14) : アロケータを受け取り、イテレータから flat_multimap オブジェクトを構築する。構築には insert() が用いられる。
(15) : key_compare とアロケータを受け取り、イテレータから flat_multimap オブジェクトを構築する。構築には insert() が用いられる。
(16) : イテレータ（ソート済み）から flat_multimap オブジェクトを構築する。
(17) : アロケータを受け取り、イテレータ（ソート済み）から flat_multimap オブジェクトを構築する。
(18) : key_compare とアロケータを受け取り、イテレータ（ソート済み）から flat_multimap オブジェクトを構築する。
(19) : Rangeから flat_multimap オブジェクトを構築する。構築には insert_range() が用いられる。
(20) : key_compare を受け取り、Rangeから flat_multimap オブジェクトを構築する。構築には insert_range() が用いられる。
(21) : アロケータを受け取り、Rangeから flat_multimap オブジェクトを構築する。構築には insert_range() が用いられる。
(22) : key_compare とアロケータを受け取り、Rangeから flat_multimap オブジェクトを構築する。構築には insert_range() が用いられる。
(23) : initializer_listから flat_multimap オブジェクトを構築する。構築には insert() が用いられる。
(24) : アロケータを受け取り、initializer_listから flat_multimap オブジェクトを構築する。構築には insert() が用いられる。
(25) : key_compare とアロケータを受け取り、initializer_listから flat_multimap オブジェクトを構築する。構築には insert() が用いられる。
(26) : initializer_list（ソート済み）から flat_multimap オブジェクトを構築する。
(27) : アロケータを受け取り、initializer_list（ソート済み）から flat_multimap オブジェクトを構築する。
(28) : key_compare とアロケータを受け取り、initializer_list（ソート済み）から flat_multimap オブジェクトを構築する。

計算量

(1)-(4) : 定数時間。
(5) : 引数 x のサイズに対して線形時間。
(6) : 引数 x の containers をムーブした計算量と同じ。
(7)-(9) : 引数 key_cont のサイズを N とすると、key_cont がソート済みなら N に対して線形時間。そうでなければ N log(N)。
(10)-(12) : 引数 key_cont および mapped_cont をムーブした計算量と同じ。
(13)-(15) : 引数 first と last の距離を N とすると、イテレータの値が value_compare に基づきソート済みなら N に対して線形時間。そうでなければ N log(N)。
(16)-(18) : 引数 first と last の距離を N とすると、N に対して線形時間。
(19)-(22) : ranges::distance(rg) を N とすると、要素の値が value_compare に基づきソート済みなら N に対して線形時間。そうでなければ N log(N)。
(23)-(25) : 引数 il のサイズを N とすると、イテレータの値が value_compare に基づきソート済みなら N に対して線形時間。そうでなければ N log(N)。
(26)-(28) : 引数 il のサイズを N とすると、N に対して線形時間。

備考

通常の（アロケータを指定しない）コピーコンストラクタとムーブコンストラクタは自動生成される。
(7)-(12) において、引数の key_cont と mapped_cont のサイズが異なる場合の動作は定められていない。
(3)-(6), (8), (9), (11), (12), (14), (15), (17), (18), (21), (22), (24), (25), (27), (28) は引数としてアロケータを受け取るが、引数のアロケータに対して uses_allocator が false であれば、この引数は無視される。

例

#include <flat_map>
#include <iostream>
#include <string>
#include <vector>

void print(const std::flat_multimap<std::string, int>& fm)
{
  std::cout << "{" << std::endl;
  for (const auto& kv: fm) {
    std::cout << "  " << kv.first << ": " << kv.second << "," << std::endl;
  }
  std::cout << "}" << std::endl;
}

int main()
{
  std::cout << "(1)" << std::endl;
  {
    std::flat_multimap<std::string, int> fm;
    print(fm);
  }
  std::cout << std::endl;

  std::cout << "(5)" << std::endl;
  {
    std::vector<std::string> keys = {"Alice", "Bob", "Carol", "Alice"};
    std::vector<int> values = {3, 1, 4, 1};

    std::flat_multimap<std::string, int> fm(keys, values);
    print(fm);
  }
  std::cout << std::endl;

  std::cout << "(23)" << std::endl;
  {
    std::initializer_list<std::pair<std::string, int>> elems = {{"Alice", 3}, {"Bob", 1}, {"Carol", 4}, {"Alice", 1}};

    std::flat_multimap<std::string, int> fm(elems);
    print(fm);
  }
  std::cout << std::endl;
}

xxxxxxxxxx
 
#include <flat_map>
#include <iostream>
#include <string>
#include <vector>
​
void print(const std::flat_multimap<std::string, int>& fm)
{
  std::cout << "{" << std::endl;
  for (const auto& kv: fm) {
    std::cout << "  " << kv.first << ": " << kv.second << "," << std::endl;
  }
  std::cout << "}" << std::endl;
}
​
int main()
{
  std::cout << "(1)" << std::endl;
  {

出力

(1)
{
}

(5)
{
  Alice: 3,
  Alice: 1,
  Bob: 1,
  Carol: 4,
}

(23)
{
  Alice: 3,
  Alice: 1,
  Bob: 1,
  Carol: 4,
}

Class / Function / Type

Header file

Other / All

std::flat_multimap::コンストラクタ

概要

効果

計算量

備考

例

出力

バージョン

言語

処理系

関連項目