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

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

阿新 • • 發佈：2018-12-19

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

  1. try_emplace ()   (C++17)
  2. emplace ()
  3. insert()

下面給出一段測試程式碼，觀察物件在新增到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 << "--------------------------------" << 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 --------------------------------

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

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

其中(6)只調用了2次建構函式，(2)呼叫了2次建構函式和1次轉移建構函式，(4)呼叫了2次建構函式和2次轉移建構函式，(5)(7)呼叫了2次建構函式和4次轉移建構函式，(1)呼叫了2次建構函式和1次拷貝建構函式，(1)呼叫了2次建構函式和2次拷貝建構函式。但目前還不能說新增操作的效率排名也是一樣。


#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();

      if (x1.money >= std::numeric_limits<int>::max()) {
        cout << endl;
      }
      if (p1.money >= std::numeric_limits<int>::max()) {
        cout << endl;
      }
    }

    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;
  }


  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  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();

      if (x1.money >= std::numeric_limits<int>::max()) {
        cout << endl;
      }
      if (p1.money >= std::numeric_limits<int>::max()) {
        cout << endl;
      }
    }

    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;
  }
}


int main() {
   testMapAdd();

  return 0;
}

執行結果：

--------------------------------//map --------------------------------//(1) 936421200:      936.421 --------------------------------//(2) 925403300:      925.403 --------------------------------//(3) 985265100:      985.265 --------------------------------//(4) 981455200:      981.455 --------------------------------//(5) 961330000:      961.33 --------------------------------//(6) 991594200:      991.594 --------------------------------//unordered_map --------------------------------//(1) 289984000:      289.984 --------------------------------//(2) 286092800:      286.093 --------------------------------//(3) 283640400:      283.64 --------------------------------//(4) 286383700:      286.384 --------------------------------//(5) 286144700:      286.145 --------------------------------//(6) 282564400:      282.564

 從數值上看，這幾種方式的效率相差並不大，可能是編譯器優化的結果。

相關推薦

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

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::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進行訪問控制，以

實戰c++中的vector系列--對vector使用std::find 和 std::find_if 演算法

之前部落格講了一些關於std::find和std::find_ if的一些用法，但是沒有講述對於vector中儲存的是自定義的類，那麼怎麼樣使用std::find和std::find_if進行查詢呢？ 先定義一個類： class Item { private

執行緒與互斥鎖（C++11中std::thread和std::mutex的用法）

執行緒 0 首先是曾經在MultiCMOS專案中用到的： #include <thread> //包含標頭檔案 class IDataProcessUnit { protected: