C++ 字典 map详解

2019-01-18 23:32:08 lh_lyh 阅读数 1123更多

文章目录

容器重要属性

通过键值访问，而不是位置
按Key有序排列
键与值一一对应
键唯一，不存在相同的键对应不同的值

操作

迭代器

1. begin 指向起始

2. end 指向末尾

3. rbegin 指向倒序起始（即末尾）

4. rend 指向倒序末尾（即起始）

// map::begin/end
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;

  mymap['b'] = 100;
  mymap['a'] = 200;
  mymap['c'] = 300;

  // show content:
  for (std::map<char,int>::iterator it=mymap.begin(); it!=mymap.end(); ++it)
    std::cout << it->first << " => " << it->second << '\n';

  return 0;
}
// Output:
//	a => 200
//	b => 100
//	c => 300

大小

1. empty 判断容器是否为空

// map::empty
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;

  mymap['a']=10;
  mymap['b']=20;
  mymap['c']=30;

  while (!mymap.empty())
  {
    std::cout << mymap.begin()->first << " => " << mymap.begin()->second << '\n';
    mymap.erase(mymap.begin());
  }

  return 0;
}

//Output:
//a => 10
//b => 20
//c => 30

2. size 返回容器大小

// map::size
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;
  mymap['a']=101;
  mymap['b']=202;
  mymap['c']=302;

  std::cout << "mymap.size() is " << mymap.size() << '\n';

  return 0;
}
//Output:
//mymap.size() is 3

3. max_size 返回容器最大尺寸

元素访问

1. operater[ ]

2. at

// accessing mapped values: at / operator[]
#include <iostream>
#include <string>
#include <map>

int main ()
{
 std::map<std::string,int> mymap = {
               { "alpha", 0 },
               { "beta", 0 },
               { "gamma", 0 } };

 mymap.at("alpha") = 10;
 mymap["beta"] = 20;
 mymap.at("gamma") = 30;

 for (auto& x: mymap) {
   std::cout << x.first << ": " << x.second << '\n';
 }

 return 0;
}
//Output:
//alpha: 10
//beta: 20
//gamma: 30

修改元素

1. insert 插入元素

方法一：直接插入键值对mymap.insert ( std::pair<char,int>('a',100) );
方法二：通过迭代器指定位置并插入std::map<char,int>::iterator it = mymap.begin(); mymap.insert (it, std::pair<char,int>('b',300)); // max efficiency inserting
方法三：通过迭代器范围插入，区间半包含（[ , )）
std::map<char,int> anothermap; anothermap.insert(mymap.begin(),mymap.find('c'));

// map::insert (C++98)
#include <iostream>
#include <map>

int main ()
{
 std::map<char,int> mymap;

 // first insert function version (single parameter):
 mymap.insert ( std::pair<char,int>('a',100) );
 mymap.insert ( std::pair<char,int>('z',200) );

 std::pair<std::map<char,int>::iterator,bool> ret;
 ret = mymap.insert ( std::pair<char,int>('z',500) );
 if (ret.second==false) {
   std::cout << "element 'z' already existed";
   std::cout << " with a value of " << ret.first->second << '\n';
 }

 // second insert function version (with hint position):
 std::map<char,int>::iterator it = mymap.begin();
 mymap.insert (it, std::pair<char,int>('b',300));  // max efficiency inserting
 mymap.insert (it, std::pair<char,int>('c',400));  // no max efficiency inserting

 // third insert function version (range insertion):
 std::map<char,int> anothermap;
 anothermap.insert(mymap.begin(),mymap.find('c'));

 // showing contents:
 std::cout << "mymap contains:\n";
 for (it=mymap.begin(); it!=mymap.end(); ++it)
   std::cout << it->first << " => " << it->second << '\n';

 std::cout << "anothermap contains:\n";
 for (it=anothermap.begin(); it!=anothermap.end(); ++it)
   std::cout << it->first << " => " << it->second << '\n';

 return 0;
}
//Output:
//element 'z' already existed with a value of 200
//mymap contains:
//a => 100
//b => 300
//c => 400
//z => 200
//anothermap contains:
//a => 100
//b => 300

2. erase 删除元素

// erasing from map
#include <iostream>
#include <map>

int main ()
{
 std::map<char,int> mymap;
 std::map<char,int>::iterator it;

 // insert some values:
 mymap['a']=10;
 mymap['b']=20;
 mymap['c']=30;
 mymap['d']=40;
 mymap['e']=50;
 mymap['f']=60;

 it=mymap.find('b');
 mymap.erase (it);                   // erasing by iterator

 mymap.erase ('c');                  // erasing by key

 it=mymap.find ('e');
 mymap.erase ( it, mymap.end() );    // erasing by range

 // show content:
 for (it=mymap.begin(); it!=mymap.end(); ++it)
   std::cout << it->first << " => " << it->second << '\n';

 return 0;
}
//Output:
//a => 10
//d => 40

3. swap 交换两个map容器内容

// swap maps
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> foo,bar;

  foo['x']=100;
  foo['y']=200;

  bar['a']=11;
  bar['b']=22;
  bar['c']=33;

  foo.swap(bar);

  std::cout << "foo contains:\n";
  for (std::map<char,int>::iterator it=foo.begin(); it!=foo.end(); ++it)
    std::cout << it->first << " => " << it->second << '\n';

  std::cout << "bar contains:\n";
  for (std::map<char,int>::iterator it=bar.begin(); it!=bar.end(); ++it)
    std::cout << it->first << " => " << it->second << '\n';

  return 0;
}
//Output:
//foo contains:
//a => 11
//b => 22
//c => 33
//bar contains:
//x => 100
//y => 200

4. clear 清除容器

5. emplace 构造并插入元素

// map::emplace
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;

  mymap.emplace('x',100);
  mymap.emplace('y',200);
  mymap.emplace('z',100);

  std::cout << "mymap contains:";
  for (auto& x: mymap)
    std::cout << " [" << x.first << ':' << x.second << ']';
  std::cout << '\n';

  return 0;
}
//Output:
//mymap contains: [x:100] [y:200] [z:100]

操作

1. 赋值

// assignment operator with maps
#include <iostream>
#include <map>

int main ()
{
 std::map<char,int> first;
 std::map<char,int> second;

 first['x']=8;
 first['y']=16;
 first['z']=32;

 second=first;                // second now contains 3 ints
 first=std::map<char,int>();  // and first is now empty

 std::cout << "Size of first: " << first.size() << '\n';
 std::cout << "Size of second: " << second.size() << '\n';
 return 0;
}
//Output:
//Size of first: 0
//Size of second: 3

2. find 获得指向元素的迭代器

// map::find
#include <iostream>
#include <map>

int main ()
{
 std::map<char,int> mymap;
 std::map<char,int>::iterator it;

 mymap['a']=50;
 mymap['b']=100;
 mymap['c']=150;
 mymap['d']=200;

 it = mymap.find('b');
 if (it != mymap.end())
   mymap.erase (it);

 // print content:
 std::cout << "elements in mymap:" << '\n';
 std::cout << "a => " << mymap.find('a')->second << '\n';
 std::cout << "c => " << mymap.find('c')->second << '\n';
 std::cout << "d => " << mymap.find('d')->second << '\n';

 return 0;
}
//Output:
//elements in mymap:
//a => 50
//c => 150
//d => 200

3. count 对某个键的元素计数

// map::count
#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;
  char c;

  mymap ['a']=101;
  mymap ['c']=202;
  mymap ['f']=303;

  for (c='a'; c<'h'; c++)
  {
    std::cout << c;
    if (mymap.count(c)>0)
      std::cout << " is an element of mymap.\n";
    else 
      std::cout << " is not an element of mymap.\n";
  }

  return 0;
}
//Output:
//a is an element of mymap.
//b is not an element of mymap.
//c is an element of mymap.
//d is not an element of mymap.
//e is not an element of mymap.
//f is an element of mymap.
//g is not an element of mymap.

4. lower_bound 返回下边界的迭代器

返回指向该元素的迭代器

5. upper_bound 返回上边界的迭代器

返回指向该元素的下一个元素的迭代器

// map::lower_bound/upper_bound
#include <iostream>
#include <map>

int main ()
{
 std::map<char,int> mymap;
 std::map<char,int>::iterator itlow,itup;

 mymap['a']=20;
 mymap['b']=40;
 mymap['c']=60;
 mymap['d']=80;
 mymap['e']=100;

 itlow=mymap.lower_bound ('b');  // itlow points to b
 itup=mymap.upper_bound ('d');   // itup points to e (not d!)

 mymap.erase(itlow,itup);        // erases [itlow,itup)

 // print content:
 for (std::map<char,int>::iterator it=mymap.begin(); it!=mymap.end(); ++it)
   std::cout << it->first << " => " << it->second << '\n';

 return 0;
}
//Output:
//a => 20
//e => 100

6. equal_range 获得相同元素的范围

相关阅读:
阻塞赋值和非阻塞赋值
组合逻辑和时序逻辑
信道估计常用算法
Verilog有限状态机FSM
希尔伯特变换
微信小程序取消分享的两种方式
orm 常用字段
drf获取请求过来时的request
WeChat--API
Django之admin源码浅析

原文地址：https://www.cnblogs.com/grj001/p/12223496.html