當前位置：首頁 > 编程语言 > c/c++ >内容正文

c/c++

C++ map 使用详解(含C++20新特性)

發布時間：2024/2/28 c/c++ 22 豆豆

生活随笔收集整理的這篇文章主要介紹了 C++ map 使用详解(含C++20新特性) 小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

簡介

map 是一個關聯容器，它提供一對一的數據處理能力（其中第一個稱為鍵，每個鍵只能在 map 中出現一次，第二個稱為該鍵的值，不同鍵的值可以相同），由于這個特性，它完成有可能在我們處理一對一數據的時候，在編程上提供快速通道。

map 內部構建一棵紅黑樹（一種非嚴格意義上的平衡二叉樹），這顆樹具有對數據自動排序的功能，所以在 map 內部所有的數據都是有序的。與另一個常用的容器 vector 相比，map 的優勢體現在查詢和刪除操作上。由于 map 內部是一棵紅黑樹，所以查詢操作的時間復雜度為O(logn)。map 在刪除元素時，不需要移動大量的元素，雖然有時需要調整樹的結構，但時間消耗遠遠小于 vector 移動元素的時間，時間復雜度為O(1)。

訪問元素

at()用于訪問指定元素

T&?at(?const?Key&?key?);????????????????????(since C++11) const?T&?at(?const?Key&?key?)?const;????????(since C++11)

返回對鍵值等于的元素映射值的引用 key。如果不存在這樣的元素，則引發類型為std::out_of_range的異常。

operator[]用于訪問或插入指定元素

T&?operator[](?const?Key&?key?); T&?operator[](?Key&&?key?);????????????(since C++11)

返回對該值的引用，該值映射到鍵key。如果該鍵不存在，則執行插入，反之，則覆蓋原來的值。

#include <iostream> #include <string> #include <vector> #include <map>int main() {std::map<char, int> letter_counts {{'a', 27}, {'b', 3}, {'c', 1}};std::cout << "initially:\n";for (const auto &pair : letter_counts) {std::cout << pair.first << ": " << pair.second << '\n';}letter_counts['b'] = 42; // update an existing valueletter_counts['x'] = 9; // insert a new valuestd::cout << "after modifications:\n";for (const auto &pair : letter_counts) {std::cout << pair.first << ": " << pair.second << '\n';}// count the number of occurrences of each word// (the first call to operator[] initialized the counter with zero)std::map<std::string, size_t> word_map;for (const auto &w : { "this", "sentence", "is", "not", "a", "sentence","this", "sentence", "is", "a", "hoax"}) {++word_map[w];}for (const auto &pair : word_map) {std::cout << pair.second << " occurrences of word '" << pair.first << "'\n";} }輸出： initially: a: 27 b: 3 c: 1 after modifications: a: 27 b: 42 c: 1 x: 9 2 occurrences of word 'a' 1 occurrences of word 'hoax' 2 occurrences of word 'is' 1 occurrences of word 'not' 3 occurrences of word 'sentence' 2 occurrences of word 'this'

迭代器

begin()?& cbegin()

iterator begin()?noexcept; const_iterator begin()?const?noexcept; const_iterator cbegin()?const?noexcept;

將迭代器返回到的第一個元素?map，如果的 map 值為空，則返回的迭代器將等于end()。

end()?& cend()

iterator end()?noexcept; const_iterator end()?const?noexcept; const_iterator cend()?const?noexcept;

將迭代器返回到的最后一個元素之后的元素?map。此元素充當占位符；嘗試訪問它會導致未定義的行為。

#include <iostream> #include <map>int main() {std::map<int, float> num_map;num_map[4] = 4.13;num_map[9] = 9.24;num_map[1] = 1.09;// calls a_map.begin() and a_map.end()for (auto it = num_map.begin(); it != num_map.end(); ++it) {std::cout << it->first << ", " << it->second << '\n';} }輸出： 1, 1.09 4, 4.13 9, 9.24

rbegin()?& crbegin()

reverse_iterator rbegin()?noexcept; const_reverse_iterator rbegin()?const?noexcept; const_reverse_iterator crbegin()?const?noexcept;

將反向迭代器返回給 reversed 的第一個元素 map，它對應于 non-reversed 的最后一個元素 map。如果 map 為空，則返回的迭代器等于rend()。

rend()?& crend()

reverse_iterator rend()?noexcept; const_reverse_iterator rend()?const?noexcept; const_reverse_iterator crend()?const?noexcept;

返回反向迭代器，該迭代器返回 reversed 的最后一個元素之后的元素 map。它對應于 non-reversed 的第一個元素之前的元素 map。該元素充當占位符，嘗試訪問它會導致未定義的行為。

容量

empty()檢查容器是否無元素

[[nodiscard]]?bool?empty()?const?noexcept; #include <map> #include <iostream> #include <utility>int main() {std::map<int,int> numbers;std::cout << "Initially, numbers.empty(): " << numbers.empty() << '\n';numbers.emplace(42, 13);numbers.insert(std::make_pair(13317, 123)); std::cout << "After adding elements, numbers.empty(): " << numbers.empty() << '\n'; }輸出： Initially, numbers.empty(): 1 After adding elements, numbers.empty(): 0

size()返回容器中的元素數

size_type size()?const?noexcept; #include <map> #include <iostream>int main() { std::map<int,char> nums {{1, 'a'}, {3, 'b'}, {5, 'c'}, {7, 'd'}};std::cout << "nums contains " << nums.size() << " elements.\n"; }輸出： nums contains 4 elements.

max_size()?返回根據系統或庫實現限制的容器可保有的元素最大數量

size_type max_size()?const?noexcept; #include <iostream> #include <map>int main() {std::map<char,char> s;std::cout << "Maximum size of a 'map' is " << s.max_size() << "\n"; }輸出： Maximum size of a 'map' is 576460752303423487

修改操作

clear()

void?clear()?noexcept;

從容器去除所有元素。此調用后?size()?返回零。非法化任何指代所含元素的引用、指針或迭代器。任何尾后迭代器保持合法。

insert()

(1)std::pair<iterator,bool>?insert(?const?value_type&?value?); (2)template<?class?P?>std::pair<iterator,bool>?insert(?P&&?value?); (3)std::pair<iterator,bool>?insert(?value_type&&?value?); (4)iterator insert(?const_iterator hint,?const?value_type&?value?); (5)template<?class?P?>iterator insert(?const_iterator hint, P&&?value?); (6)iterator insert(?const_iterator hint, value_type&&?value?); (7)template<?class?InputIt?>void?insert(?InputIt first, InputIt last?); (8)void?insert(?std::initializer_list<value_type>?ilist?); (9)insert_return_type insert(node_type&&?nh); (10)iterator insert(const_iterator hint, node_type&&?nh);

若容器尚未含有帶等價關鍵的元素，則插入元素到容器中。返回值:

(1-3)?返回由指向被插入元素的迭代器（或阻止插入的元素的迭代器）和指代插入是否發生的?bool?組成的 pair 。

(4-6)?返回指向被插入元素的迭代器，或指向阻止插入的元素的迭代器。

(7-8)?（無）

(9)?返回?insert_return_type?，其成員初始化如下：若?nh?為空，則?inserted?為?false?，?position?為?end()?，而?node?為空。否則發生插入，?inserted?為?true?，?position?指向被插入元素，而?node?為空。若插入失敗，則?inserted為?false?，?node?擁有?nh?的先前值，而?position?指向擁有等價于?nh.key()?的關鍵的元素。

(10)?若?nh?為空則為尾迭代器，若插入發生則為指向被插入元素的迭代器，而若插入失敗則為指向擁有等價于?nh.key()?的關鍵的元素的迭代器。

常用實例：

// 定義一個map對象 map<int,?string>?Mapasd; // 第一種用insert函數插入pair Mapasd.insert(pair<int, string>(0, "zero"));// 第二種用make_pair函數，無需寫出型別，就可以生成一個pair對象 Mapasd.insert(make_pair(1, "qwe"));// 第三種用insert函數插入value_type數據 Mapasd.insert(map<int, string>::value_type(2, "student_one"));// 第四種用"array"方式插入 Mapasd[1] = "first"; Mapasd[2] = "second";

上面常用的三種方法，雖然都可以實現數據的插入，但是它們是有區別的，第一種和第二種在效果上是完成一樣的，用insert函數插入數據，當map中存在該關鍵字時，insert 操作不再插入這條數據。但是用數組方式就不同了，它可以覆蓋該關鍵字所對應的值。

#include <iomanip> #include <iostream> #include <map> #include <string>using namespace std::literals;template<typename It> void printInsertionStatus(It it, bool success) {std::cout << "Insertion of " << it->first << (success ? " succeeded\n" : " failed\n"); }int main() {std::map<std::string, float> karasunoPlayerHeights;// 重載 3 ：從右值引用插入const auto [it_hinata, success] = karasunoPlayerHeights.insert({"Hinata"s, 162.8});printInsertionStatus(it_hinata, success);{// 重載 1 ：從左值引用插入const auto [it, success2] = karasunoPlayerHeights.insert(*it_hinata);printInsertionStatus(it, success2);}{// 重載 2 ：經由轉發到 emplace 插入const auto [it, success] = karasunoPlayerHeights.insert({"Kageyama", 180.6});printInsertionStatus(it, success);}{// 重載 6 ：帶位置提示從右值引用插入const std::size_t n = std::size(karasunoPlayerHeights);const auto it = karasunoPlayerHeights.insert(it_hinata, {"Azumane"s, 184.7});printInsertionStatus(it, std::size(karasunoPlayerHeights) != n);}{// 重載 4 ：帶位置提示從左值引用插入const std::size_t n = std::size(karasunoPlayerHeights);const auto it = karasunoPlayerHeights.insert(it_hinata, *it_hinata);printInsertionStatus(it, std::size(karasunoPlayerHeights) != n);}{// 重載 5 ：帶位置提示經由轉發到 emplace 插入const std::size_t n = std::size(karasunoPlayerHeights);const auto it = karasunoPlayerHeights.insert(it_hinata, {"Tsukishima", 188.3});printInsertionStatus(it, std::size(karasunoPlayerHeights) != n);}auto node_hinata = karasunoPlayerHeights.extract(it_hinata);std::map<std::string, float> playerHeights;// 重載 7 ：從范圍插入playerHeights.insert(std::begin(karasunoPlayerHeights), std::end(karasunoPlayerHeights));// 重載 8 ：從 initializer_list 插入playerHeights.insert({{"Kozume"s, 169.2}, {"Kuroo", 187.7}});// 重載 9 ：插入結點const auto status = playerHeights.insert(std::move(node_hinata));printInsertionStatus(status.position, status.inserted);node_hinata = playerHeights.extract(status.position);{// 重載 10 ：插入結點帶位置提示const std::size_t n = std::size(playerHeights);const auto it = playerHeights.insert(std::begin(playerHeights), std::move(node_hinata));printInsertionStatus(it, std::size(playerHeights) != n);}// 打印結果 mapstd::cout << std::left << '\n';for (const auto& [name, height] : playerHeights)std::cout << std::setw(10) << name << " | " << height << "cm\n"; }輸出： Insertion of Hinata succeeded Insertion of Hinata failed Insertion of Kageyama succeeded Insertion of Azumane succeeded Insertion of Hinata failed Insertion of Tsukishima succeeded Insertion of Hinata succeeded Insertion of Hinata succeededAzumane | 184.7cm Hinata | 162.8cm Kageyama | 180.6cm Kozume | 169.2cm Kuroo | 187.7cm Tsukishima | 188.3cm

insert_or_assign()

(1)template?<class?M>pair<iterator,?bool>?insert_or_assign(const?key_type&?k, M&&?obj); (2)template?<class?M>pair<iterator,?bool>?insert_or_assign(key_type&&?k, M&&?obj); (3)template?<class?M>iterator insert_or_assign(const_iterator hint,?const?key_type&?k, M&&?obj); (4)template?<class?M>iterator insert_or_assign(const_iterator hint, key_type&&?k, M&&?obj);

(1,3)?若等價于?k?的鍵已存在于容器中，則賦值std::forward <M>(obj)給對應于鍵?k?的?mapped_type?。若鍵不存在，則如同用 insert?插入從?value_type(k,?std::forward <M>(obj))?構造的新值。

(2,4)?同?(1,3)?，除了從?value_type(std::move(k),?std::forward <M>(obj))?構造被映射值。

#include <iostream> #include <map> #include <string>int main() {std::map<std::string, std::string> myMap;myMap.insert_or_assign("a", "apple" );myMap.insert_or_assign("b", "bannana" );myMap.insert_or_assign("c", "cherry" );myMap.insert_or_assign("c", "clementine");for (const auto &pair : myMap) {std::cout << pair.first << " : " << pair.second << '\n';} }a : apple b : bannana c : clementine

emplace()

template<?class...?Args?> std::pair<iterator,bool>?emplace(?Args&&...?args?);

若容器中無擁有該關鍵的元素，則插入以給定的?args?原位構造的新元素到容器。細心地使用?emplace?允許在構造新元素的同時避免不必要的復制或移動操作。準確地以與提供給?emplace?者相同的參數，通過 std::forward<Args>(args)...?轉發調用新元素（即 std::pair<const?Key, T>?）的構造函數。即使容器中已有擁有該關鍵的元素，也可能構造元素，該情況下新構造的元素將被立即銷毀。

#include <iostream> #include <utility> #include <string> #include <map>int main() {std::map<std::string, std::string> m;// 使用 pair 的移動構造函數m.emplace(std::make_pair(std::string("a"), std::string("a")));// 使用 pair 的轉換移動構造函數m.emplace(std::make_pair("b", "abcd"));// 使用 pair 的模板構造函數m.emplace("d", "ddd");// 使用 pair 的逐片構造函數m.emplace(std::piecewise_construct,std::forward_as_tuple("c"),std::forward_as_tuple(10, 'c'));// C++17 起，能使用 m.try_emplace("c", 10, 'c');for (const auto &p : m) {std::cout << p.first << " => " << p.second << '\n';} }輸出： a => a b => abcd c => cccccccccc d => ddd

emplace_hint()

template?<class...?Args> iterator emplace_hint(?const_iterator hint, Args&&...?args?);

插入元素到盡可能靠近正好在?hint?之前的位置。原位構造元素，即不進行復制或移動操作。

try_emplace()

(1)template?<class...?Args>pair<iterator,?bool>?try_emplace(const?key_type&?k, Args&&...?args); (2)template?<class...?Args>pair<iterator,?bool>?try_emplace(key_type&&?k, Args&&...?args); (3)template?<class...?Args>iterator try_emplace(const_iterator hint,?const?key_type&?k, Args&&...?args); (4)template?<class...?Args>iterator try_emplace(const_iterator hint, key_type&&?k, Args&&...?args);

(1)?若容器中已存在等于?k?的鍵，則不做任何事。否則行為類似emplace，除了以?value_type(std::piecewise_construct, std::forward_as_tuple(k), std::forward_as_tuple(std::forward<Args>(args)...))?構造元素

(2)?若容器中已存在等于?k?的鍵，則不做任何事。否則行為類似emplace?，除了以?value_type(std::piecewise_construct, std::forward_as_tuple(std::move(k)), std::forward_as_tuple(std::forward<Args>(args)...))?構造元素

(3)?若容器中已存在等于?k?的鍵，則不做任何事。否則行為類似emplace_hint，除了以?value_type(std::piecewise_construct, std::forward_as_tuple(k), std::forward_as_tuple(std::forward<Args>(args)...))?構造元素

(4)?若容器中已存在等于?k?的鍵，則不做任何事。否則行為類似emplace_hint，除了以?value_type(std::piecewise_construct, std::forward_as_tuple(std::move(k)), std::forward_as_tuple(std::forward<Args>(args)...))?構造元素

注意：不同于 insert?或 emplace?，若不發生插入，則這些函數不從右值參數移動，這令操縱 value 為僅移動類型的 map ，如?std::map<std::string, std::unique_ptr<foo>>?更為容易。另外，?try_emplace?分離地處理關鍵和到?mapped_type?的參數，不同于要求參數構造?value_type?（即一個?std::pair?）的?emplace?。

#include <iostream> #include <utility> #include <string>#include <map> int main() {using namespace std::literals;std::map<std::string, std::string> m;m.try_emplace("a", "a"s);m.try_emplace("b", "abcd");m.try_emplace("c", 10, 'c');m.try_emplace("c", "Won't be inserted");for (const auto &p : m) {std::cout << p.first << " => " << p.second << '\n';} }輸出： a => a b => abcd c => cccccccccc

erase()

(1)iterator erase(?const_iterator pos?);iterator erase(?iterator pos?); (2)iterator erase(?const_iterator first, const_iterator last?); (3)size_type erase(?const?key_type&?key?);

從容器移除指定的元素。指向被擦除元素的引用和迭代器被非法化。其他引用和迭代器不受影響。

(1)?移除位于?pos?的元素。

(2)?移除范圍?[first; last)?中的元素，它必須是?*this?中的合法范圍。

(3)?移除關鍵等于?key?的元素（若存在一個），成功返回 1，失敗返回 0 。

常與find() 函數配合使用：

map<int ,string>test; map<int ,string>::iterator it; it = test.find(123);if(it == test.end())cout << "do not find 123" <<endl; else ?test.erase(it); #include <map> #include <iostream> int main() {std::map<int, std::string> c = {{1, "one"}, {2, "two"}, {3, "three"},{4, "four"}, {5, "five"}, {6, "six"}};// 從 c 擦除所有奇數for(auto it = c.begin(); it != c.end(); )if(it->first % 2 == 1)it = c.erase(it);else++it;for(auto& p : c)std::cout << p.second << ' '; }輸出： two four six

swap()

void?swap(?map&?other?)?noexcept;

將內容與?other?的交換。不在單個元素上調用任何移動、復制或交換操作。所有迭代器和引用保持合法，尾后迭代器被非法化。

extract()

(1)node_type extract(?const_iterator position?);???(C++17 起) (2)node_type extract(?const?key_type&?x?);??? ????(C++17 起)

(1)?解鏈含?position?所指向元素的結點并返回占有它的節點句柄。

(2)?若容器擁有元素而其鍵等于值?x?，則從容器解鏈該元素并返回占有它的節點句柄。否則，返回空結點把柄。

任何情況下，均不復制或移動元素，只重指向容器結點的內部指針（可能出現再平衡，和?erase()?一樣）。釋出結點會非法化指向被釋出元素的迭代器。指向被釋出元素的指針和引用保持合法，但在結點把柄占有該元素時不能使用：若元素被插入容器，就能使用它們。

注意:extract 是更換 map 的鍵而不重分配的唯一方式。

map<int, string> m{{1, "mango"}, {2, "papaya"}, {3, "guava"}}; auto nh = m.extract(2); nh.key() = 4; m.insert(move(nh)); // m == {{1, "mango"}, {3, "guava"}, {4, "papaya"}}

merge()

template<class?C2> void?merge(std::map<Key, T, C2, Allocator>&?source); template<class?C2> void?merge(std::map<Key, T, C2, Allocator>&&?source); template<class?C2> void?merge(std::multimap<Key, T, C2, Allocator>&?source); template<class?C2> void?merge(std::multimap<Key, T, C2, Allocator>&&?source);

試圖釋出（"接合"）?source?中每個元素，并用?*this?的比較對象插入到?*this?。若?*this?中有元素，其關鍵等價于來自?source中元素的關鍵，則不從?source?釋出該元素。不復制或移動元素，只會重指向容器結點的內部指針。指向被轉移元素的所有指針和引用保持合法，但現在指代到?*this?中而非到?source?中。若?get_allocator()?!=?source.get_allocator()?則行為未定義。

#include <map> #include <iostream> #include <string>int main() {std::map<int, std::string> ma {{1, "apple"}, {5, "pear"}, {10, "banana"}};std::map<int, std::string> mb {{2, "zorro"}, {4, "batman"}, {5, "X"}, {8, "alpaca"}};std::map<int, std::string> u;u.merge(ma);std::cout << "ma.size(): " << ma.size() << '\n';u.merge(mb);std::cout << "mb.size(): " << mb.size() << '\n';std::cout << "mb.at(5): " << mb.at(5) << '\n';for(auto const &kv: u)std::cout << kv.first << ", " << kv.second << '\n'; }輸出： ma.size(): 0 mb.size(): 1 mb.at(5): X 1, apple 2, zorro 4, batman 5, pear 8, alpaca 10, banana

查找

count()

(1)size_type count(?const?Key&?key?)?const; (2)template<?class?K?>?size_type count(?const?K&?x?)?const;

返回鍵 key 的元素數，因為此容器不允許重復，故返回值為 0?或 1。

(1)?返回擁有關鍵?key?的元素數。

(2)?返回鍵等于值?x?的元素數。此重載僅若有限定 id?Compare::is_transparent?合法且指代一個類型才參與重載決議。這允許調用此函數而不構造?Key?的實例。

find()

(1)iterator find(?const?Key&?key?); (2)const_iterator find(?const?Key&?key?)?const; (3)template<?class?K?>?iterator find(?const?K&?x?); (4)template<?class?K?>?const_iterator find(?const?K&?x?)?const;

(1-2)?尋找鍵等于?key?的的元素。

(3-4)?尋找鍵等于值?x?的元素。此重載僅若若有限定 id?Compare::is_transparent?合法并且指代類型才參與重載決議。允許調用此函數而無需構造?Key?的實例。

find() 函數返回一個指向鍵為key的元素的迭代器，如果沒找到則返回指向map尾部的迭代器。常用方法如下：

map<int, string>test; map<int, string>::iterator it; it = test.find(123);if( it == test.end())cout << "do not find 123" <<endl; else cout << "find 123" <<endl; #include <iostream> #include <map> struct FatKey { int x; int data[1000]; }; struct LightKey { int x; }; bool operator<(const FatKey& fk, const LightKey& lk) { return fk.x < lk.x; } bool operator<(const LightKey& lk, const FatKey& fk) { return lk.x < fk.x; } bool operator<(const FatKey& fk1, const FatKey& fk2) { return fk1.x < fk2.x; } int main() { // 簡單比較演示std::map<int,char> example = {{1,'a'},{2,'b'}};auto search = example.find(2);if (search != example.end()) {std::cout << "Found " << search->first << " " << search->second << '\n';} else {std::cout << "Not found\n";}// 通透比較演示std::map<FatKey, char, std::less<>> example2 = { { {1, {} },'a'}, { {2, {} },'b'} };LightKey lk = {2};auto search2 = example2.find(lk);if (search2 != example2.end()) {std::cout << "Found " << search2->first.x << " " << search2->second << '\n';} else {std::cout << "Not found\n";} }輸出： Found 2 b Found 2 b

contains()

(1)bool?contains(?const?Key&?key?)?const; (2)template<?class?K?>?bool?contains(?const?K&?x?)?const;

(1)?檢查容器中是否有鍵等于?key?的元素。

(2)?檢查是否有鍵等于值?x?的元素。此重載僅若有限定 id?Compare::is_transparent?合法且代表類型才參與重載決議。它允許調用此函數而無需構造?Key?的實例。

#include <iostream> #include <map>int main() { std::map<int,char> example = {{1,'a'},{2,'b'}};if (example.contains(2)) {std::cout << "Found\n";} else {std::cout << "Not found\n";} }輸出： Found

equal_range()

(1)std::pair<iterator,iterator>?equal_range(?const?Key&?key?); (2)std::pair<const_iterator,const_iterator>?equal_range(?const?Key&?key?)?const; (3)template<?class?K?> std::pair<iterator,iterator>?equal_range(?const?K&?x?); (4)template<?class?K?> std::pair<const_iterator,const_iterator>?equal_range(?const?K&?x?)?const;

返回容器中所有擁有給定鍵的元素范圍。范圍以兩個迭代器定義，一個指向首個不小于?key?的元素，另一個指向首個大于?key?的元素。首個迭代器可以換用 lower_bound()?獲得，而第二迭代器可換用 upper_bound()?獲得。

(1,2)?比較關鍵與?key?。

(3,4)?比較關鍵與值?x?。此重載僅若有限定 id?Compare::is_transparent?合法且指代一個類型才參與重載決議。它們允許調用此函數而不構造?Key?的實例。

#include <map> #include <iostream>int main() {const std::map<int, const char*> m{{ 0, "zero" },{ 1, "one" },{ 2, "two" },};{auto p = m.equal_range(1);for (auto& q = p.first; q != p.second; ++q) {std::cout << "m[" << q->first << "] = " << q->second << '\n';}if (p.second == m.find(2)) {std::cout << "end of equal_range (p.second) is one-past p.first\n";} else {std::cout << "unexpected; p.second expected to be one-past p.first\n";}}{auto pp = m.equal_range(-1);if (pp.first == m.begin()) {std::cout << "pp.first is iterator to first not-less than -1\n";} else {std::cout << "unexpected pp.first\n";}if (pp.second == m.begin()) {std::cout << "pp.second is iterator to first element greater-than -1\n";} else {std::cout << "unexpected pp.second\n";}}{auto ppp = m.equal_range(3);if (ppp.first == m.end()) {std::cout << "ppp.first is iterator to first not-less than 3\n";} else {std::cout << "unexpected ppp.first\n";}if (ppp.second == m.end()) {std::cout << "ppp.second is iterator to first element greater-than 3\n";} else {std::cout << "unexpected ppp.second\n";}} }輸出： m[1] = one end of equal_range (p.second) is one-past p.first pp.first is iterator to first not-less than -1 pp.second is iterator to first element greater-than -1 ppp.first is iterator to first not-less than 3 ppp.second is iterator to first element greater-than 3

lower_bound()

(1)iterator lower_bound(?const?Key&?key?);const_iterator lower_bound(?const?Key&?key?)?const; (2)template<?class?K?>?iterator lower_bound(const?K&?x);template<?class?K?>?const_iterator lower_bound(const?K&?x)?const;

(1)?返回首個不小于?key?的元素的迭代器。
(2)?返回首個不小于值?x?的元素的迭代器。此重載僅若有限定 id?Compare::is_transparent?合法并指代一個類型才參與重載決議。它們允許調用此函數而無需構造?Key?的實例。

upper_bound()

(1)iterator upper_bound(?const?Key&?key?);const_iterator upper_bound(?const?Key&?key?)?const; (2)template<?class?K?>?iterator upper_bound(?const?K&?x?);template<?class?K?>?const_iterator upper_bound(?const?K&?x?)?const;

(1)?返回指向首個大于?key?的元素的迭代器。

(2)?返回指向首個大于值?x?的元素的迭代器。此重載僅若有限定 id?Compare::is_transparent?合法并指代一個類型才參與重載決議。這允許調用此函數而無需構造?Key?的實例。

std::swap(std::map)

emplate<?class?Key,?class?T,?class?Compare,?class?Alloc?> void?swap(?map<Key,T,Compare,Alloc>&?lhs,?map<Key,T,Compare,Alloc>&?rhs?)?noexcept(/* see below */);

為?std::map?特化?std::swap 算法。交換?lhs?與?rhs?的內容。調用?lhs.swap(rhs)?。

std::erase_if?(std::map)

template<?class?Key,?class?T,?class?Compare,?class?Alloc,?class?Pred?> typename?std::map<Key,T,Compare,Alloc>::size_typeerase_if(std::map<Key,T,Compare,Alloc>&?c, Pred pred);

從容器中去除所有滿足謂詞?pred?的元素。等價于:

auto old_size = c.size();for (auto i = c.begin(), last = c.end(); i != last; ) {if (pred(*i)) {i = c.erase(i);} else {++i;}}return old_size - c.size(); #include <iostream> #include <map>auto show = [](const auto& map) {std::cout << "map[" << map.size() << "] { ";for (auto const& item : map) {std::cout << "{ " << item.first << ", " << item.second << " } ";}std::cout << "}\n\n"; };auto main() -> int {std::cout << "Initial map<int, char>:" "\n";std::map<int, char> map { { 1, 'a' }, { 2, 'b' }, { 3, 'c' }, { 4, 'd' }, { 5, 'e' } };show(map);std::cout << "Remove items with odd keys:" "\n";const auto count = std::erase_if(map, [](const auto& item) {auto const& [key, value] = item;return (key & 1) == 1;});show(map);std::cout << count << " items where removed.\n"; }輸出： Initial map<int, char>: map[5] { { 1, a } { 2, b } { 3, c } { 4, d } { 5, e } }Remove items with odd keys: map[2] { { 2, b } { 4, d } }3 items where removed.

總結

以上是生活随笔為你收集整理的C++ map 使用详解(含C++20新特性)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。