2. 程式人生 > >C++：探索std::map和std::unordered_map中的新增操作

C++：探索std::map和std::unordered_map中的新增操作

阿新 • • 發佈：2018-11-11

std::map和std::unordered_map主要提供如下幾種新增操作：

  1. try_emplace ()   (C++17)
  2. emplace ()
  3. insert()
  4. [] =

下面給出一段測試程式碼，觀察物件在新增到std::map中時，構造物件過程中會有什麼區別：

#include <map>
#include <iostream>
#include <tuple>
#include <exception>
#include <string>
#include <memory>
#include <vector>

using namespace std;

class Kid {
private:
  static int cnt;
  int id;
public:
  string name;
  int age;
  Kid() {
    id = ++cnt;
    cout << "Kid()" << id << endl;
  }
  Kid(string _name, int _age) : name(_name), age(_age) {
    id = ++cnt;
    cout << "Kid(string _name, int _age)" << id << endl;
  }
  Kid(const Kid&) {
    id = ++cnt;
    cout << "Kid(const Kid&)" << id << endl;
  }
  Kid(Kid&&) {
    id = ++cnt;
    cout << "Kid(Kid&&)" << id << endl;
  }
  Kid& operator=(const Kid&) {
    cout << "operator=(const Kid&)" << id << endl;

    return *this;
  }
  bool operator< (const Kid& rhs) const
  {
    return this->age < rhs.age;
  }
};
int Kid::cnt = 0;

class People {
private:
  static int cnt;
  int id;
public:
  string name;
  int age;
  People() {
    id = ++cnt;
    cout << "People()" << id << endl;
  }
  People(string _name, int _age) : name(_name), age(_age) {
    id = ++cnt;
    cout << "People(string _name, int _age)" << id << endl;
  }
  People(const People&) {
    id = ++cnt;
    cout << "People(const People&)" << id << endl;
  }
  People(People&&) {
    id = ++cnt;
    cout << "People(People&&)" << id << endl;
  }
  People& operator=(const People&) {
    cout << "operator=(const People&)" << id << endl;
    return *this;
  }
};

int People::cnt = 0;

int main() {
  map<Kid, People> m;
  cout << "--------------------------------" << endl;
 
  {
    cout << "--------------------------------//(1)" << endl;
    Kid x1("xxl", 1213332);
    m.try_emplace(x1, "xlx", 121);
  }
  {
    cout << "--------------------------------//(2)" << endl;
    m.try_emplace(Kid("xxl", 1213332), "xlx", 121);
  }
  {
    cout << "--------------------------------//(3)" << endl;
    Kid x1("xxl", 1213332);
    People p1("xlx", 121);
    m.emplace(x1, p1);
  }
  {
    cout << "--------------------------------//(4)" << endl;
    m.emplace(Kid("xxl", 1213332), People("aaaa", 121));
  }
  {
    cout << "--------------------------------//(5)" << endl;
    m.emplace(make_pair(Kid("xxl", 1213332), People("aaaa", 121)));
  }
  {
    cout << "--------------------------------//(6)" << endl;
    m.emplace(std::piecewise_construct, std::forward_as_tuple("fffff", 999), std::forward_as_tuple("wwww", 121));
  }
  {
    cout << "--------------------------------//(7)" << endl;
    m.insert(make_pair(Kid("xxl", 1213332), People("aaaa", 121)));
  }
  {
    cout << "--------------------------------//(8)" << endl;
    m[Kid("xxl", 1213332)]= People("aaaa", 121);
  }

  cout << "--------------------------------" << endl;

  return 1;
}

VC++2017的執行結果：

--------------------------------
--------------------------------//(1)
Kid(string _name, int _age)3
Kid(const Kid&)4
People(string _name, int _age)3
--------------------------------//(2)
Kid(string _name, int _age)5
Kid(Kid&&)6
People(string _name, int _age)4
--------------------------------//(3)
Kid(string _name, int _age)7
People(string _name, int _age)5
Kid(const Kid&)8
People(const People&)6
--------------------------------//(4)
People(string _name, int _age)7
Kid(string _name, int _age)9
Kid(Kid&&)10
People(People&&)8
--------------------------------//(5)
People(string _name, int _age)9
Kid(string _name, int _age)11
Kid(Kid&&)12
People(People&&)10
Kid(Kid&&)13
People(People&&)11
--------------------------------//(6)
Kid(string _name, int _age)14
People(string _name, int _age)12
--------------------------------//(7)
People(string _name, int _age)13
Kid(string _name, int _age)15
Kid(Kid&&)16
People(People&&)14
Kid(Kid&&)17
People(People&&)15
--------------------------------//(8)
People(string _name, int _age)16
Kid(string _name, int _age)18
Kid(Kid&&)19
People()17
operator=(const People&)4
--------------------------------

從以上執行結果中可以看到，只講物件構造效率的話，效率從高到低依次為：

(6) > (2) > (4) > (5) (7) > (1) > (3) > (8)

其中(6)只調用了2次建構函式，(2)呼叫了2次建構函式和1次轉移建構函式，(4)呼叫了2次建構函式和2次轉移建構函式，(5)(7)呼叫了2次建構函式和4次轉移建構函式，(1)呼叫了2次建構函式和1次拷貝建構函式，(3)呼叫了2次建構函式和2次拷貝建構函式，(8)呼叫了3次建構函式、1次拷貝建構函式和1次賦值函式。但物件構造效率高低還不能決定新增操作的效率，即新增操作的效率排名不一定退以上排名一樣。

下面對以上幾種方式分別進行程式碼測試，程式碼如下：

#include <iostream>
#include <sstream>
#include <fstream>
#include <tuple>
#include <exception>
#include <string>
#include <vector>
#include <functional>
#include <array>
#include <chrono>
#include <unordered_map>
#include <map>
#include <cstdlib>
#include <ctime>
#include <climits>

using namespace std;

class Kid_ {
private:
  static int cnt;
  int id;
public:
  string name;
  int money;
  Kid_() {
    id = ++cnt;
  }
  Kid_(string& _name, int& _money) : name(_name), money(_money) {
    id = ++cnt;
  }
  Kid_(const Kid_& k) : name(k.name), money(k.money) {
    id = ++cnt;
  }
  Kid_(Kid_&& k) : name(move(k.name)), money(move(k.money)) {
    id = ++cnt;
  }

  bool operator< (const Kid_& rhs) const {
    return this->name < rhs.name;
  }
};
int Kid_::cnt = 0;

class People_ {
private:
  static int cnt;
  int id;
public:
  string name;
  int money;
  People_() {
    id = ++cnt;
  }
  People_(string& _name, int& _money) : name(_name), money(_money) {
    id = ++cnt;
  }
  People_(const People_& p) : name(p.name), money(p.money) {
    id = ++cnt;
  }
  People_(People_&& p) : name(move(p.name)), money(move(p.money)) {
    id = ++cnt;
  }
};
int People_::cnt = 0;

struct KeyHash {
  std::size_t operator()(const Kid_& k) const
  {
    return std::hash<string>()(k.name) ^ k.money;
  }
};

struct KeyEqual {
  bool operator()(const Kid_& lhs, const Kid_& rhs) const
  {
    return lhs.name == rhs.name && lhs.money == rhs.money;
  }
};

string getRandomString(int length) {
  string ret;

  for (int i = 0; i < length; i++) {
    int r = std::rand() % 10;

    if (i == 0 && r ==0) {  
      i--;
      continue;
    }

    ret += to_string(r);
  }

  return ret;
}

void testMapAdd() {
  std::srand(std::time(0));
  int times = 1000000;

  cout << "--------------------------------//map" << endl;

  {
    long long timeUsed = 0;
    map<Kid_, People_ > m;

    cout << "--------------------------------//(1)" << endl;
    for (int i = 0; i < times; i++) {
      string s1 = getRandomString(10);
      int r1 = std::rand();
      string s2 = getRandomString(10);
      int r2 = std::rand();

      auto start = std::chrono::system_clock::now();
      Kid_ k(s1, r1);
      m.try_emplace(k, s2, r2);
      auto end = std::chrono::system_clock::now();

      timeUsed += std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
    }

    cout << timeUsed << ":\t" << ((float)timeUsed / times) << endl;
  }
  {
    long long timeUsed = 0;
    map<Kid_, People_ > m;

    cout << "--------------------------------//(2)" << endl;
    for (int i = 0; i < times; i++) {
      string s1 = getRandomString(10);
      int r1 = std::rand();
      string s2 = getRandomString(10);
      int r2 = std::rand();

      auto start = std::chrono::system_clock::now();
      m.try_emplace(Kid_(s1, r1), s2, r2);
      auto end = std::chrono::system_clock::now();

      timeUsed += std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
    }

    cout << timeUsed << ":\t" << ((float)timeUsed / times) << endl;
  }
  {
    long long timeUsed = 0;
    map<Kid_, People_ > m;

    cout << "--------------------------------//(3)" << endl;
    for (int i = 0; i < times; i++) {
      string s1 = getRandomString(10);
      int r1 = std::rand();
      string s2 = getRandomString(10);
      int r2 = std::rand();

      auto start = std::chrono::system_clock::now();
      Kid_ x1(s1, r1);
      People_ p1(s2, r2);
      m.emplace(x1, p1);
      auto end = std::chrono::system_clock::now();

      timeUsed += std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
    }

    cout << timeUsed << ":\t" << ((float)timeUsed / times) << endl;
  }
  {
    long long timeUsed = 0;
    map<Kid_, People_ > m;

    cout << "--------------------------------//(4)" << endl;
    for (int i = 0; i < times; i++) {
      string s1 = getRandomString(10);
      int r1 = std::rand();
      string s2 = getRandomString(10);
      int r2 = std::rand();

      auto start = std::chrono::system_clock::now();
      m.emplace(Kid_(s1, r1), People_(s2, r2));
      auto end = std::chrono::system_clock::now();

      timeUsed += std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
    }

    cout << timeUsed << ":\t" << ((float)timeUsed / times) << endl;
  }
  {
    long long timeUsed = 0;
    map<Kid_, People_ > m;

    cout << "--------------------------------//(5)" << endl;
    for (int i = 0; i < times; i++) {
      string s1 = getRandomString(10);
      int r1 = std::rand();
      string s2 = getRandomString(10);
      int r2 = std::rand();

      auto start = std::chrono::system_clock::now();
      m.emplace(make_pair(Kid_(s1, r1), People_(s2, r2)));
      auto end = std::chrono::system_clock::now();

      timeUsed += std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
    }

    cout << timeUsed << ":\t" << ((float)timeUsed / times) << endl;
  }
  {
    long long timeUsed = 0;
    map<Kid_, People_ > m;

    cout << "--------------------------------//(6)" << endl;
    for (int i = 0; i < times; i++) {
      string s1 = getRandomString(10);
      int r1 = std::rand();
      string s2 = getRandomString(10);
      int r2 = std::rand();

      auto start = std::chrono::system_clock::now();
      m.emplace(std::piecewise_construct, std::forward_as_tuple(s1, r1), std::forward_as_tuple(s2, r2));
      auto end = std::chrono::system_clock::now();

      timeUsed += std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
    }

    cout << timeUsed << ":\t" << ((float)timeUsed / times) << endl;
  }
  {
    long long timeUsed = 0;
    map<Kid_, People_ > m;

    cout << "--------------------------------//(8)" << endl;
    for (int i = 0; i < times; i++) {
      string s1 = getRandomString(10);
      int r1 = std::rand();
      string s2 = getRandomString(10);
      int r2 = std::rand();

      auto start = std::chrono::system_clock::now();
      m[Kid_(s1, r1)] = People_(s2, r2);
      auto end = std::chrono::system_clock::now();

      timeUsed += std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
    }

    cout << timeUsed << ":\t" << ((float)timeUsed / times) << endl;
  }
  /////////////////////////////////////////////////////////////////////////////////////////
  cout << "--------------------------------//unordered_map" << endl;

  {
    long long timeUsed = 0;
    unordered_map<Kid_, People_, KeyHash, KeyEqual> m(3 * times);

    cout << "--------------------------------//(1)" << endl;
    for (int i = 0; i < times; i++) {
      string s1 = getRandomString(10);
      int r1 = std::rand();
      string s2 = getRandomString(10);
      int r2 = std::rand();

      auto start = std::chrono::system_clock::now();
      Kid_ k(s1, r1);
      m.try_emplace(k, s2, r2);
      auto end = std::chrono::system_clock::now();

      timeUsed += std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
    }

    cout << timeUsed << ":\t" << ((float)timeUsed / times) << endl;
  }
  {
    long long timeUsed = 0;
    unordered_map<Kid_, People_, KeyHash, KeyEqual> m(3 * times);

    cout << "--------------------------------//(2)" << endl;
    for (int i = 0; i < times; i++) {
      string s1 = getRandomString(10);
      int r1 = std::rand();
      string s2 = getRandomString(10);
      int r2 = std::rand();

      auto start = std::chrono::system_clock::now();
      m.try_emplace(Kid_(s1, r1), s2, r2);
      auto end = std::chrono::system_clock::now();

      timeUsed += std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
    }

    cout << timeUsed << ":\t" << ((float)timeUsed / times) << endl;
  }
  {
    long long timeUsed = 0;
    unordered_map<Kid_, People_, KeyHash, KeyEqual> m(3 * times);

    cout << "--------------------------------//(3)" << endl;
    for (int i = 0; i < times; i++) {
      string s1 = getRandomString(10);
      int r1 = std::rand();
      string s2 = getRandomString(10);
      int r2 = std::rand();

      auto start = std::chrono::system_clock::now();
      Kid_ x1(s1, r1);
      People_ p1(s2, r2);
      m.emplace(x1, p1);
      auto end = std::chrono::system_clock::now();

      timeUsed += std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
    }

    cout << timeUsed << ":\t" << ((float)timeUsed / times) << endl;
  }
  {
    long long timeUsed = 0;
    unordered_map<Kid_, People_, KeyHash, KeyEqual> m(3 * times);

    cout << "--------------------------------//(4)" << endl;
    for (int i = 0; i < times; i++) {
      string s1 = getRandomString(10);
      int r1 = std::rand();
      string s2 = getRandomString(10);
      int r2 = std::rand();

      auto start = std::chrono::system_clock::now();
      m.emplace(Kid_(s1, r1), People_(s2, r2));
      auto end = std::chrono::system_clock::now();

      timeUsed += std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
    }

    cout << timeUsed << ":\t" << ((float)timeUsed / times) << endl;
  }
  {
    long long timeUsed = 0;
    unordered_map<Kid_, People_, KeyHash, KeyEqual> m(3 * times);

    cout << "--------------------------------//(5)" << endl;
    for (int i = 0; i < times; i++) {
      string s1 = getRandomString(10);
      int r1 = std::rand();
      string s2 = getRandomString(10);
      int r2 = std::rand();

      auto start = std::chrono::system_clock::now();
      m.emplace(make_pair(Kid_(s1, r1), People_(s2, r2)));
      auto end = std::chrono::system_clock::now();

      timeUsed += std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
    }

    cout << timeUsed << ":\t" << ((float)timeUsed / times) << endl;
  }
  {
    long long timeUsed = 0;
    unordered_map<Kid_, People_, KeyHash, KeyEqual> m(3 * times);

    cout << "--------------------------------//(6)" << endl;
    for (int i = 0; i < times; i++) {
      string s1 = getRandomString(10);
      int r1 = std::rand();
      string s2 = getRandomString(10);
      int r2 = std::rand();

      auto start = std::chrono::system_clock::now();
      m.emplace(std::piecewise_construct, std::forward_as_tuple(s1, r1), std::forward_as_tuple(s2, r2));
      auto end = std::chrono::system_clock::now();

      timeUsed += std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
    }

    cout << timeUsed << ":\t" << ((float)timeUsed / times) << endl;
  }
  {
    long long timeUsed = 0;
    unordered_map<Kid_, People_, KeyHash, KeyEqual> m(3 * times);

    cout << "--------------------------------//(8)" << endl;
    for (int i = 0; i < times; i++) {
      string s1 = getRandomString(10);
      int r1 = std::rand();
      string s2 = getRandomString(10);
      int r2 = std::rand();

      auto start = std::chrono::system_clock::now();
      m[Kid_(s1, r1)] = People_(s2, r2);
      auto end = std::chrono::system_clock::now();

      timeUsed += std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
    }
    
    cout << timeUsed << ":\t" << ((float)timeUsed / times) << endl;
  }
}


int main() {
   testMapAdd();

  return 0;
}

執行結果：

--------------------------------//map
--------------------------------//(1)
934167100:      934.167
--------------------------------//(2)
892646600:      892.647
--------------------------------//(3)
919973300:      919.973
--------------------------------//(4)
917704500:      917.705
--------------------------------//(5)
935676700:      935.677
--------------------------------//(6)
946283500:      946.284
--------------------------------//(8)
939161000:      939.161
--------------------------------//unordered_map
--------------------------------//(1)
269299400:      269.299
--------------------------------//(2)
278339800:      278.34
--------------------------------//(3)
269483600:      269.484
--------------------------------//(4)
273019500:      273.02
--------------------------------//(5)
274466600:      274.467
--------------------------------//(6)
267864800:      267.865
--------------------------------//(8)
273746400:      273.746

 從數值上看，這幾種方式的效率相差並不大，而且每次執行的結果的排名都不完全相同。這應該是編譯器做了大量的編譯優化，所以執行效率都還是不錯的。

相關推薦

C++：探索std::map和std::unordered_map中的新增操作

std::map和std::unordered_map主要提供如下幾種新增操作： try_emplace ()   (C++17) emplace () insert() [] = 下面給出一段測試程式碼，觀察物件在新增到std::map中時，

C++：探索std::map和std::unordered_map中最高效的新增操作

std::map和std::unordered_map主要提供如下幾種新增操作： try_emplace ()   (C++17) emplace () insert() 下面給出一段測試程式碼，觀察物件在新增到std::map中時，構造物件過程中會有什麼區別： #i

std::map和std::multimap的使用總結

Map和Multimap 　　Map和Multimap（下文統稱Map）將key/value作為元素進行管理，邏輯上是一種鍵值對映關係，即資料結構中雜湊表。它們可以根據key的排序規則進行自動元素排序，Multimap允許元素重複，而Map不允許。 　　在使用Map和Multima

std::map和std::vector

通過map可以快速的通過key查詢元素，通過vector可以快速的檢視元素的個數和查詢第i個元素。map和vector都可以實現快速的元素插入 它們組合起來可以實現隨機訪問表，如： osgEarthDrivers/engine_rex/TileNodeRegistry struct

TIBCO Spotfire使用教程：Shewhart控制圖和趨勢圖中新增TIBCO Spotfire限制線

休哈特控制圖是常用於統計質量控制的流行圖表，用於監控來自商業或工業過程的資料。統計質量控制程式的目標是監控，控制和減少過程變化。這些圖表通常有三條線: 一條中心線，以及統計推匯出的上下控制閾值。它們使使用者能夠監控相對於基線歷史時段的變化過程，該過程改變測量統計的位置或可

c++ 之智慧指標：儘量使用std::make_unique和std::make_shared而不直接使用new

關於make_unique的構造及使用例程，MSDN的講解非常詳細 （https://msdn.microsoft.com/zh-cn/library/dn439780.aspx ） 使用過程中，主要有這麼幾個關鍵點： 1.  make_unique 同 uni

C++11學習筆記：std::move和std::forward原始碼分析

std::move和std::forward是C++0x中新增的標準庫函式，分別用於實現移動語義和完美轉發。下面讓我們分析一下這兩個函式在gcc4.6中的具體實現。 預備知識 引用摺疊規則： X& + & => X& X&& +

實戰c++中的vector系列--對vector&lt;自己定義類&gt;使用std::find 和 std::find_if 算法

++ pac price key fadein 輸出 var getitem mod 之前博客講了一些關於std::find和std::find_ if的一些使用方法。可是沒有講述對於vector中存儲的是自己定義的類。那麽怎麽樣使用std::find和

muduo庫中的核心：std::bind和std::function

muduo main ons 源碼 綁定 func 靜態成員 con 函數 最近在讀完陳碩大牛的《Linux多線程服務端編程》以及muduo源碼後，對其中的一些實現細節有著十分深刻的印象，尤其是使用std::bind和std::function的回調技術。可以說，這兩個大殺

C++：如何高效的使用std::vector？

目錄： 一、在std::vector尾部新增物件時應儘量使用emplace_back，而不要使用push_back 二、新增多個元素前應使用reserve設定容量，防止擴容時發生元素複製 三、刪除元素時應從最後一個元素開始刪除，不要從中間開始刪除 四、新增新物件時應從結尾處新增，而不

C++中的std::lock_guard和std::unique_lock

std::lock_guard 這是最簡單的一個管理鎖的物件。只有構造和解構函式，在構造的時候加鎖，析構的時候解鎖，解鎖後就不能使用該物件再加鎖了。可以避免使用std::mutex時忘記解鎖的情況，同時可以方便處理異常。 簡單的例項： #include <iostrea

C++有序map和無序unordered_map效能測試對比

概述 簡單對比map和unordered_map的效能。 map內部是紅黑樹，在插入元素時會自動排序，而無序容器unordered_map內部是散列表，通過雜湊而不是排序來快速操作元素，使得效率更高。當你不需要排序時選擇unordered_map的效率更高。

c++11 std::future和std::async

std::future可以從非同步任務中獲取結果，一般與std::async配合使用，std::async用於建立非同步任務，實際上就是建立一個執行緒執行相應任務。    使用程式碼如下： #include <future> #include <iostre

c++11 使用異步編程std::async和std::future

調用 color c++ wait ble 獲取 clas 種類 get 先說明一點：std::asyanc是std::future的高級封裝， 一般我們不會直接使用std::futrue，而是使用對std::future的高級封裝std::async。 下面分別說一下。

（轉）用C++11的std::async代替執行緒的建立， 以及std::future，std::promise和std::packaged_task的使用

c++11中增加了執行緒，使得我們可以非常方便的建立執行緒，它的基本用法是這樣的： void f(int n); std::thread t(f, n + 1); t.join(); 但是執行緒畢竟是屬於比較低層次的東西，有時候使用有些不便，比如我希望獲取執

【C++併發實戰】（三） std::future和std::promise

std::future和std::promise std::future std::future期待一個返回，從一個非同步呼叫的角度來說，future更像是執行函式的返回值，C++標準庫使用std::future為一次性事件建模，如果一個事件需要等待特定的一次性事件，那麼這執行緒可以獲取一個future物

【C++並發實戰】（三） std::future和std::promise

指向 code 實例 value 互斥 stdfuture 通過 模板 som std::future和std::promise std::future std::future期待一個返回，從一個異步調用的角度來說，future更像是執行函數的返回值，C++標準庫使用std

C++11之std::function和std::bind

std::function是可呼叫物件的包裝器，它最重要的功能是實現延時呼叫： #include "stdafx.h" #include<iostream>// std::cout #include<functional>// std::fu

C++11 中std::function和std::bind的用法

關於std::function 的用法： 其實就可以理解成函式指標 1. 儲存自由函式 void printA(int a) { cout<<a<<endl; } std::function<void(int a)

C++11:基於std::queue和std::mutex構建一個執行緒安全的佇列

C++中的模板std::queue提供了一個佇列容器,但這個容器並不是執行緒安全的，如果在多執行緒環境下使用佇列，它是不能直接拿來用的。 基於它做一個執行緒安全的佇列也並不複雜。基本的原理就是用std::mutext訊號量對std::queue進行訪問控制，以