std::unordered_multimap

std::unordered_multimap

介绍

成员函数

  • 构造析构
  • 元素访问
  • 迭代器
  • 容量
  • 修改器
  • 查找
  • 桶接口
  • 哈希策略

非成员函数

介绍

// unordered_multimap 模板定义
template, class KeyEqual = std::equal_to,
    class Allocator = std::allocator< std::pair>> class unordered_multimap;	(C++11 起)
namespace pmr {
    template , class Pred = std::equal_to>
    using unordered_multimap = std::unordered_multimap>>;(C++17 起)
}
  • std::unordered_multimap 介绍摘选自 cppreference.com 中文网 std::unordered_multimap 介绍
  • unordered_multimap 是无序关联容器
  • 支持等价的键(一个 unordered_multimap 可含有每个键值的多个副本)和将键与另一类型的值关联
  • unordered_multimap 类支持向前迭代器。搜索、插入和移除拥有平均常数时间复杂度
  • 元素在内部不以任何特定顺序排序,但被组织到桶中。元素被放进哪个桶完全依赖于其键的哈希值
  • 这允许快速地访问单独的元素,因为只要哈希值被计算出来,它就准确地指代元素所被放入的桶
  • 不要求此容器的迭代顺序稳定(故例如 std::equal 不能用于比较二个 std::unordered_multimap )
  • 除了键比较等价(以 key_eq() 为比较器比较相等)的每组元素在迭代顺序中组成相接的子范围,它亦可用 equal_range() 访问
  • 同一个键可对应存放多个值,std::unordered_map同一个键值只能有一个对应的值

成员函数

构造析构
#include 
#include 
#include 
#include 
#include 

auto Print(const std::string &msg,
           const std::unordered_multimap &lst) {
  std::cout << msg << " : ";
  for (const auto &pa : lst) {
    std::cout << pa.first << " -> " << pa.second << "\t";
  }
  std::cout << "\n";
}

struct Key {
  int first;
  int second;
}; // 自定义Key 结构

struct KeyHash {
  std::size_t operator()(const Key &k) const {
    return std::hash{}(k.first) ^ (std::hash{}(k.second) << 1);
  }
}; // 自定义哈希结构

struct KeyEqual {
  bool operator()(const Key &lhs, const Key &rhs) const {
    return lhs.first == rhs.first && lhs.second == rhs.second;
  }
}; // 自定义 Key 比较结构

// 自定义 Key 打印函数
auto Print(const std::string &msg,
           const std::unordered_multimap &lst) {
  std::cout << msg << " : ";
  for (const auto &pa : lst) {
    std::cout << pa.first.first << ":" << pa.first.second << " -> " << pa.second
              << "\t";
  }
  std::cout << "\n";
}

int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using umap_int = std::unordered_multimap;
  umap_int m1; //默认构造
  Print("m1", m1);

  umap_int m2(10); //设置桶数量
  Print("m2", m2);
  std::allocator> alloc;
  std::unordered_multimap m3(10, KeyHash(),
                                                          KeyEqual(), alloc);
  Print("m3", m3);

  umap_int m4(10, alloc); //设置桶数量和分配器
  Print("m4", m4);
  umap_int m5(alloc); //设置分配器
  Print("m5", m5);

  umap_int m6{{1, 10}, {2, 20}, {3, 30}, {3, 50}}; //初始化列表
  Print("m6", m6);

  umap_int m7(m6.begin(), m6.end()); //迭代器初始化,基于范围
  Print("m7", m7);

  std::unordered_multimap m8 = {
      {{1, 10}, 100},
      {{2, 20}, 200},
      {{3, 30}, 300},
      {{3, 30}, 400}}; //初始化列表
  Print("m8", m8);

  std::unordered_multimap m9(
      m8.begin(), m8.end(), 10, KeyHash(), KeyEqual(),
      alloc); //迭代器初始化,基于范围
  Print("m9", m9);

  umap_int m10 = {{3, 1}, {4, 1}, {5, 9}, {5, 6}}; //初始化列表
  Print("m10", m10);

  umap_int m11(m10); //拷贝构造初始化,可设置分配器
  Print("m11", m11);
  umap_int m12(m11, alloc);
  Print("m12", m12);

  umap_int m13(std::move(m12)); //移动构造初始化,可设置分配器
  Print("m13", m13);
  umap_int m14(std::move(m13), alloc);
  Print("m14", m14);

  //析构函数默认
  return 0; // a.exec();
}

输出结果:
m1 :
m2 :
m3 :
m4 :
m5 :
m6 : 1 -> 10 2 -> 20 3 -> 30 3 -> 50
m7 : 1 -> 10 2 -> 20 3 -> 30 3 -> 50
m8 : 1:10 -> 100 2:20 -> 200 3:30 -> 300 3:30 -> 400
m9 : 1:10 -> 100 2:20 -> 200 3:30 -> 300 3:30 -> 400
m10 : 3 -> 1 4 -> 1 5 -> 9 5 -> 6
m11 : 3 -> 1 4 -> 1 5 -> 9 5 -> 6
m12 : 3 -> 1 4 -> 1 5 -> 9 5 -> 6
m13 : 3 -> 1 4 -> 1 5 -> 9 5 -> 6
m14 : 3 -> 1 4 -> 1 5 -> 9 5 -> 6

元素访问
auto Print(const std::string &msg,
           const std::unordered_multimap &lst) {
  std::cout << msg << " : ";
  for (const auto &pa : lst) {
    std::cout << pa.first << " -> " << pa.second << "\t";
  }
  std::cout << "\n";
}

int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using umap_int = std::unordered_multimap;
  umap_int m1{{1, 10}, {2, 20}, {2, 30}, {3, 30}};
  Print("m1", m1);

  std::cout << "m1 : ";
  for (const auto &pa : m1) {
    std::cout << pa.first << " -> " << pa.second << "\t";
  }
  std::cout << "\n";
  return 0; // a.exec();
}

输出结果:
m1 : 1 -> 10 2 -> 20 2 -> 30 3 -> 30
m1 : 1 -> 10 2 -> 20 2 -> 30 3 -> 30

迭代器
int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using umap_int = std::unordered_multimap;
  umap_int m1{{1, 10}, {2, 20}, {2, 30}, {3, 30}};
  umap_int::iterator iter = m1.begin(); // 返回指向起始的迭代器
  std::cout << "m1 : ";
  for (; iter != m1.end(); ++iter) {
    std::cout << iter->first << " -> " << iter->second << "\t";
  }
  std::cout << '\n';

  umap_int::const_iterator citer = m1.begin(); // 返回指向起始的迭代器,const
  std::cout << "m1 : ";
  for (; citer != m1.end(); ++citer) {
    std::cout << citer->first << " -> " << citer->second << "\t";
  }
  std::cout << '\n';
  return 0; // a.exec();
}

输出结果:
m1 : 1 -> 10 2 -> 20 2 -> 30 3 -> 30
m1 : 1 -> 10 2 -> 20 2 -> 30 3 -> 30

容量
auto Print(const std::string &msg, const std::unordered_multimap &lst) {
  std::cout << msg << " : ";
  for (const auto &pa : lst) {
    std::cout << pa.first << " -> " << pa.second << "\t";
  }
  std::cout << "\n";
}

int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using umap_int = std::unordered_multimap;
  umap_int m1{{1, 10}, {2, 20}, {2, 30}, {3, 30}};
  Print("m1", m1);

  //检查容器是否为空
  std::cout << std::boolalpha << "m1.empty() : " << m1.empty() << std::endl;
  std::cout << "m1.size() : " << m1.size() << std::endl; //返回容纳的元素数
  std::cout << "m1.max_size() : " << m1.max_size() << std::endl; //返回可容纳的最大元素数,和平台有关
  return 0;               // a.exec();
}

输出结果:
m1 : 1 -> 10 2 -> 20 2 -> 30 3 -> 30
s1.empty() : false
s1.size() : 4
s1.max_size() : 768614336404564650

修改器
auto Print(const std::string &msg,
           const std::unordered_multimap &lst) {
  std::cout << msg << " : ";
  for (const auto &pa : lst) {
    std::cout << pa.first << " -> " << pa.second << "\t";
  }
  std::cout << "\n";
}

int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using umap_int = std::unordered_multimap;
  umap_int m1{{1, 10}, {2, 20}, {2, 30}, {3, 30}};
  Print("m1", m1);

  m1.clear(); //  清除内容
  Print("m1", m1);
  m1.insert({10, 100}); //插入元素或结点
  Print("m1", m1);
  m1.emplace(20, 200); //原位构造元素
  Print("m1", m1);

  m1.emplace_hint(m1.end(), 30, 300); //使用提示原位构造元素
  Print("m1", m1);

  m1.erase(m1.begin()); //擦除元素
  Print("m1", m1);

  umap_int m2;
  m2.swap(m1);
  Print("m1", m1);
  Print("m2", m2);
  return 0; // a.exec();
}

输出结果:
m1 : 1 -> 10 2 -> 20 2 -> 30 3 -> 30
m1 :
m1 : 10 -> 100
m1 : 10 -> 100 20 -> 200
m1 : 10 -> 100 20 -> 200 30 -> 300
m1 : 20 -> 200 30 -> 300
m1 :
m2 : 20 -> 200 30 -> 300

查找
auto Print(const std::string &msg,
           const std::unordered_multimap &lst) {
  std::cout << msg << " : ";
  for (const auto &pa : lst) {
    std::cout << pa.first << " -> " << pa.second << "\t";
  }
  std::cout << "\n";
}

int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using umap_int = std::unordered_multimap;
  umap_int m1{{1, 10}, {2, 20}, {2, 30}, {3, 30}, {3, 40}};
  Print("m1", m1);

  // 返回匹配特定键的元素数量
  std::cout << "m1.count(1) : " << m1.count(1) << std::endl;
  std::cout << "m1.count(2) : " << m1.count(2) << std::endl;
  std::cout << "m1.count(3) : " << m1.count(3) << std::endl;

  // 寻找带有特定键的元素,返回 key 对应的任意一个值的迭代器
  umap_int::const_iterator iter = m1.find(3);
  if (iter != m1.cend()) {
    std::cout << "m1.find(3) : " << iter->first << " -> " << iter->second
              << std::endl;
  } else {
    std::cout << "m1.find(3) : m1.cend()" << std::endl;
  }

  // 返回容器中所有键等于 key 的元素范围
  // 返回容器中所有键等于 key
  // 的元素范围。范围以二个迭代器定义,第一个指向所需范围的首元素,而第二个指向范围的尾后一位元素。
  // 返回含有容器中所有键等价于 x 的元素的范围。此重载只有在有限定标识
  // Hash::is_transparent 与 KeyEqual::is_transparent
  // 均合法并指代类型时才参与重载决议。这假设能用 K 和 Key 类型一起调用这种 Hash
  // 还有 KeyEqual 是通透的,进而允许不用构造 Key 的实例就调用此函数
  std::pair pa = m1.equal_range(3);
  if (pa.first == m1.end())
    std::cout << "pa.first is empty" << std::endl;
  else
    std::cout << "m1.equal_range(3) first : " << pa.first->first << " -> "
              << pa.first->second << std::endl;
  if (pa.second == m1.end())
    std::cout << "pa.second is empty" << std::endl;
  else
    std::cout << "m1.equal_range(3) second : " << pa.second->first << " -> "
              << pa.second->second << std::endl;
  return 0; // a.exec();
}

输出结果:
m1.count(3) : 2
m1.find(3) : 3 -> 30
m1.equal_range(3) first : 3 -> 30
pa.second is empty

非成员函数

auto Print(const std::string &msg,
           const std::unordered_multimap &lst) {
  std::cout << msg << " : ";
  for (const auto &pa : lst) {
    std::cout << pa.first << " -> " << pa.second << "\t";
  }
  std::cout << "\n";
}

int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using umap_int = std::unordered_multimap;

  umap_int m1{{1, 10}, {2, 20}, {3, 30}};
  umap_int m2{{1, 10}, {2, 20}, {2, 30}, {3, 30}, {3, 40}};
  Print("m1", m1);
  Print("m2", m2);

  std::cout << std::boolalpha << "m1 == m2 : " << (m1 == m2) << std::endl;

  umap_int m3;
  std::swap(m3, m2);
  Print("m2", m2);
  Print("m3", m3);
  return 0; // a.exec();
}

输出结果:
m1 : 1 -> 10 2 -> 20 3 -> 30
m2 : 1 -> 10 2 -> 20 2 -> 30 3 -> 30 3 -> 40
m1 == m2 : false
m2 :
m3 : 1 -> 10 2 -> 20 2 -> 30 3 -> 30 3 -> 40

桶接口
auto Print(const std::string &msg,
           const std::unordered_multimap &lst) {
  std::cout << msg << " : ";
  for (const auto &pa : lst) {
    std::cout << pa.first << " -> " << pa.second << "\t";
  }
  std::cout << "\n";
}

int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using umap_int = std::unordered_multimap;
  umap_int m1;
  m1.emplace(1, 2);
  m1.emplace(10, 20);
  m1.emplace(100, 200);
  m1.emplace(1000, 2000);
  m1.emplace(1000, 3000);
  Print("m1", m1);

  //返回一个迭代器,指向指定的桶的开始
  for (int i = 0; i < m1.bucket_count(); ++i) {
    auto iter = m1.begin(i);
    if (iter == m1.end(i)) {
      std::cout << "m1.end(" << i << ")"
                << "\t";
    } else {
      for (; iter != m1.end(i); ++iter) {
        std::cout << "m1.begin(" << i << ") : " << iter->first << " -> "
                  << iter->second << "\t";
      }
    }
  }
  std::cout << "\n";

  //返回一个迭代器,指向指定的桶的开始
  for (int i = 0; i < m1.bucket_count(); ++i) {
    auto iter = m1.cbegin(i);
    if (iter == m1.cend(i)) {
      std::cout << "m1.cend(" << i << ")"
                << "\t";
    } else {
      for (; iter != m1.cend(i); ++iter) {
        std::cout << "m1.cbegin(" << i << ") : " << iter->first << " -> "
                  << iter->second << "\t";
      }
    }
  }
  std::cout << "\n";

  //返回桶数
  std::cout << "m1.bucket_count() : " << m1.bucket_count() << std::endl;
  //返回桶的最大数量
  std::cout << "m1.max_bucket_count() : " << m1.max_bucket_count() << std::endl;
  //返回在特定的桶中的元素数量
  for (int i = 0; i < m1.bucket_count(); ++i) {
    std::cout << "m1.bucket_size(" << i << ") : " << m1.bucket_size(i) << "\t";
  }
  std::cout << "\n";

  //返回带有特定键的桶,返回关键 key 的桶的下标。始终会在此桶中找到关键等于 key
  //的元素(若存在)。返回值仅对 bucket_count() 返回相同值的容器实例合法。
  //若 bucket_count() 为零则行为未定义
  std::cout << "m1.bucket(1) : " << m1.bucket(1) << std::endl;
  std::cout << "m1.bucket(100) : " << m1.bucket(100) << std::endl;

  // 键不存在,若存在会分配当前下标的桶
  std::cout << "m1.bucket(5000) : " << m1.bucket(5000) << std::endl;
  std::cout << "m1.bucket(2) : " << m1.bucket(2) << std::endl;
  return 0; // a.exec();
}

输出结果:
m1.cend(0) m1.cbegin(1) : 100 -> 200 m1.cend(2) m1.cend(3) m1.cbegin(4) : 1000 -> 2000 m1.cbegin(4) : 1000 -> 3000 m1.cbegin(4) : 1 -> 2 m1.cend(5) m1.cend(6) m1.cbegin(7) : 10 -> 20
m1.bucket_count() : 8
m1.max_bucket_count() : 1152921504606846975
m1.bucket_size(0) : 0 m1.bucket_size(1) : 1 m1.bucket_size(2) : 0 m1.bucket_size(3) : 0 m1.bucket_size(4) : 3 m1.bucket_size(5) : 0 m1.bucket_size(6) : 0 m1.bucket_size(7) : 1
m1.bucket(1) : 4
m1.bucket(100) : 1
m1.bucket(5000) : 4
m1.bucket(2) : 7

哈希策略
auto Print(const std::string &msg,
           const std::unordered_multimap &lst) {
  std::cout << msg << " : ";
  for (const auto &pa : lst) {
    std::cout << pa.first << " -> " << pa.second << "\t";
  }
  std::cout << "\n";
}

int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using umap_int = std::unordered_multimap;
  umap_int m1;
  m1.emplace(1, 2);
  m1.emplace(10, 20);
  m1.emplace(100, 200);
  m1.emplace(1000, 2000);
  m1.emplace(1000, 3000);
  Print("m1", m1);

  for (int i = 0; i < m1.bucket_count(); ++i) {
    auto iter = m1.begin(i);
    if (iter == m1.end(i)) {
      std::cout << "m1.end(" << i << ")"
                << "\t";
    } else {
      for (; iter != m1.end(i); ++iter) {
        std::cout << "m1.begin(" << i << ") : " << iter->first << " -> "
                  << iter->second << "\t";
      }
    }
  }
  std::cout << "\n";

  //返回每个桶的平均元素数量
  std::cout << "m1.load_factor() : " << m1.load_factor() << std::endl;

  for (int i = 0; i < m1.bucket_count(); ++i) {
  }

  //管理每个桶的平均元素数量的最大值
  //管理最大加载因子(每个桶的平均元素数)。若加载因子超出此阈值,则容器自动增加桶数
  //返回最大加载因子
  std::cout << "m1.max_load_factor() : " << m1.max_load_factor() << std::endl;
  //设置最大加载因子
  m1.max_load_factor(0.9);
  std::cout << "m1.max_load_factor() : " << m1.max_load_factor() << std::endl;

  //为至少为指定数量的桶预留存储空间并重新生成散列表
  //设置桶数为 count并重哈希容器,即考虑桶总数已改变,再把元素放到适当的桶中
  //若新的桶数使加载因子大于最大加载因子( count < size() / max_load_factor() )
  //则新桶数至少为 size() / max_load_factor()
  m1.rehash(16);
  for (int i = 0; i < m1.bucket_count(); ++i) {
    auto iter = m1.begin(i);
    if (iter == m1.end(i)) {
      std::cout << "m1.end(" << i << ")"
                << "\t";
    } else {
      for (; iter != m1.end(i); ++iter) {
        std::cout << "m1.begin(" << i << ") : " << iter->first << " -> "
                  << iter->second << "\t";
      }
    }
  }
  std::cout << "\n";

  //为至少为指定数量的元素预留存储空间并重新生成哈希表
  //设置桶数为适应至少 count 个元素,而不超出最大加载因子所需的数
  //并重哈希容器,即考虑桶数已更改后将元素放进适合的桶
  //等效地调用 rehash(std::ceil(count / max_load_factor()))
  m1.reserve(20);
  for (int i = 0; i < m1.bucket_count(); ++i) {
    auto iter = m1.begin(i);
    if (iter == m1.end(i)) {
      std::cout << "m1.end(" << i << ")"
                << "\t";
    } else {
      for (; iter != m1.end(i); ++iter) {
        std::cout << "m1.begin(" << i << ") : " << iter->first << " -> "
                  << iter->second << "\t";
      }
    }
  }
  std::cout << "\n";
  return 0; // a.exec();
}

输出结果:
m1 : 1000 -> 2000 1000 -> 3000 1 -> 2 10 -> 20 100 -> 200
m1.end(0) m1.begin(1) : 100 -> 200 m1.end(2) m1.end(3) m1.begin(4) : 1000 -> 2000 m1.begin(4) : 1000 -> 3000 m1.begin(4) : 1 -> 2 m1.end(5) m1.end(6) m1.begin(7) : 10 -> 20
m1.load_factor() : 0.625
m1.max_load_factor() : 1
m1.max_load_factor() : 0.9
m1.end(0) m1.begin(1) : 100 -> 200 m1.end(2) m1.end(3) m1.begin(4) : 1 -> 2 m1.end(5) m1.end(6) m1.end(7) m1.end(8) m1.end(9) m1.end(10) m1.end(11) m1.begin(12) : 1000 -> 2000 m1.begin(12) : 1000 -> 3000 m1.end(13) m1.end(14) m1.begin(15) : 10 -> 20
m1.end(0) m1.end(1) m1.end(2) m1.end(3) m1.begin(4) : 1 -> 2 m1.end(5) m1.end(6) m1.end(7) m1.end(8) m1.end(9) m1.end(10) m1.end(11) m1.end(12) m1.end(13) m1.end(14) m1.end(15) m1.end(16) m1.begin(17) : 100 -> 200 m1.end(18) m1.end(19) m1.end(20) m1.end(21) m1.end(22) m1.end(23) m1.end(24) m1.end(25) m1.end(26) m1.end(27) m1.begin(28) : 1000 -> 2000 m1.begin(28) : 1000 -> 3000 m1.end(29) m1.end(30) m1.begin(31) : 10 -> 20

起始

你可能感兴趣的:(c++,stl,c++)