map

构造函数

empty (1)

 explicit map (const key_compare& comp = key_compare(),
       const allocator_type& alloc = allocator_type());

 explicit map (const allocator_type& alloc);

range (2)

 template <class InputIterator>
  map (InputIterator first, InputIterator last,
        const key_compare& comp = key_compare(),
        const allocator_type& = allocator_type());

copy (3)

 map (const map& x);
 map (const map& x, const allocator_type& alloc);

move (4)

 map (map&& x);
 map (map&& x, const allocator_type& alloc);

initializer list (5)

 map (initializer_list<value_type> il,
  const key_compare& comp = key_compare(),
  const allocator_type& alloc = allocator_type());

赋值运算符

copy (1)

map& operator= (const map& x);

move (2)

map& operator= (map&& x);

initializer list (3)

map& operator= (initializer_list<value_type> il);

迭代器

容量

##元素访问

##修改

emplace函数

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

如果其键是唯一的，则在地图中插入一个新元素。这个新元素是使用args作为构造一个value_type（它是一个对类型的对象）的参数来构建的。

仅当容器中没有其他元素具有与放置的密钥相同的密钥（映射容器中的键是唯一的）时，才会进行插入。

如果插入，这有效地将容器尺寸增加1。

在内部，映射容器将按照其比较对象指定的标准将其所有元素按其键进行排序。该元素总是插入其相应的位置.

元素通过使用转发的args调用allocator_traits :: construct来就地构建。存在类似的成员函数insert，它将现有对象复制或移动到容器中。

###emlpace_hint函数

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

用提示构造和插入元素

提示可以插入元素的位置。

如果位置指向要插入元素应该插入的位置,则该函数优化其插入时间。

注意，这不强制新元素必须在提示的位置上.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;
  auto it = mymap.end();

  it = mymap.emplace_hint(it,'b',10);
  mymap.emplace_hint(it,'a',12);
  mymap.emplace_hint(mymap.end(),'c',14);

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

  return 0;
}

操作

find函数

iterator find (const key_type& k);
const_iterator find (const key_type& k) const;

获取所查找元素的迭代器

(1)搜索容器中具有等效于k的键的元素，如果找到则返回一个迭代器，否则返回一个迭代器到map :: end。

(2)如果容器的比较对象反射返回false（即无论元素作为参数传递的顺序），两个键都被视为等效的。另一个成员函数map :: count可以用来检查特定的键是否存在。

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


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

count函数

size_type count (const key_type& k) const;

用特定的键计数元素搜索容器中具有等效于k的密钥的元素，并返回匹配数。

因为map容器中的所有元素都是唯一的，所以该函数只能返回1（如果找到该元素）或零（否则）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


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

lower_bound函数

iterator lower_bound（const key_type＆k）;
const_iterator lower_bound（const key_type＆k）const;

返回迭代器下限

该函数将返回一个迭代器到其不小于k的第一个元素

该函数使用其内部比较对象（key_comp）来确定这一点，将迭代器返回到key_comp（element_key，k）将返回false的第一个元素。

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


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

upper_bound函数

iterator upper_bound（const key_type＆k）;
const_iterator upper_bound（const key_type＆k）const;

返回迭代器上限

该函数将返回一个迭代器到其大于k的第一个元素

该函数使用其内部比较对象（key_comp）来确定这一点，将迭代器返回到key_comp（k，element_key）将返回true的第一个元素。

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


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

equal_range函数

pair<const_iterator,const_iterator> equal_range (const key_type& k) const;
pair<iterator,iterator>             equal_range (const key_type& k);

获得相等元素的范围

返回包含容器中具有等价于k的key的所有元素的范围。

由于map容器中的元素具有唯一的键，返回的范围最多只包含一个元素。

如果没有找到匹配项，则返回的范围的长度为零，两个迭代器都指向第一个元素.

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


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

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

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

  std::pair<std::map<char,int>::iterator,std::map<char,int>::iterator> ret;
  ret = mymap.equal_range('b');

  std::cout << "lower bound points to: ";
  std::cout << ret.first->first << " => " << ret.first->second << '\n';

  std::cout << "upper bound points to: ";
  std::cout << ret.second->first << " => " << ret.second->second << '\n';

  return 0;
}

multimap

迭代器

容量

修改

##操作

lower_bound函数

iterator lower_bound（const key_type＆k）;
const_iterator lower_bound（const key_type＆k）const;

该函数将返回一个迭代器到其不小于k的第一个元素的迭代器

该函数使用其内部比较对象（key_comp）来确定这一点，将迭代器返回到key_comp（element_key，k）将返回false的第一个元素。

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <iostream>
#include <map>

int main ()
{
  std::multimap<char,int> mymultimap;
  std::multimap<char,int>::iterator it,itlow,itup;

  mymultimap.insert(std::make_pair('a',10));
  mymultimap.insert(std::make_pair('b',121));
  mymultimap.insert(std::make_pair('c',1001));
  mymultimap.insert(std::make_pair('c',2002));
  mymultimap.insert(std::make_pair('d',11011));
  mymultimap.insert(std::make_pair('e',44));

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

  // print range [itlow,itup):
  for (it=itlow; it!=itup; ++it)
    std::cout << (*it).first << " => " << (*it).second << '\n';

  return 0;
}

upper_bound函数

 iterator upper_bound (const key_type& k);
const_iterator upper_bound (const key_type& k) const;

返回迭代器上限

该函数将返回key大于k的第一个元素的迭代器

该函数使用其内部比较对象（key_comp）来确定这一点，将迭代器返回到key_comp（k，element_key）将返回true的第一个元素。

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <iostream>
#include <map>

int main ()
{
  std::multimap<char,int> mymultimap;
  std::multimap<char,int>::iterator it,itlow,itup;

  mymultimap.insert(std::make_pair('a',10));
  mymultimap.insert(std::make_pair('b',121));
  mymultimap.insert(std::make_pair('c',1001));
  mymultimap.insert(std::make_pair('c',2002));
  mymultimap.insert(std::make_pair('d',11011));
  mymultimap.insert(std::make_pair('e',44));

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

  // print range [itlow,itup):
  for (it=itlow; it!=itup; ++it)
    std::cout << (*it).first << " => " << (*it).second << '\n';

  return 0;
}

equal_range函数

pair<const_iterator,const_iterator> equal_range (const key_type& k) const;
pair<iterator,iterator>             equal_range (const key_type& k);

获得相等元素的范围

返回包含容器中具有等价于k的key的所有元素的范围的范围。如果没有找到匹配项，则返回的范围的长度为零，两个迭代器都指向第一个元素，该元素根据容器的内部比较对象（key_comp）被认为是经过k处理的。如果容器的比较对象反射性返回false（即无论密钥作为参数传递的顺序），两个关键字都被视为等效的。

示例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


#include <iostream>
#include <map>

int main ()
{
  std::multimap<char,int> mymm;

  mymm.insert(std::pair<char,int>('a',10));
  mymm.insert(std::pair<char,int>('b',20));
  mymm.insert(std::pair<char,int>('b',30));
  mymm.insert(std::pair<char,int>('b',40));
  mymm.insert(std::pair<char,int>('c',50));
  mymm.insert(std::pair<char,int>('c',60));
  mymm.insert(std::pair<char,int>('d',60));

  std::cout << "mymm contains:\n";
  for (char ch='a'; ch<='d'; ch++)
  {
    std::pair <std::multimap<char,int>::iterator, std::multimap<char,int>::iterator> ret;
    ret = mymm.equal_range(ch);
    std::cout << ch << " =>";
    for (std::multimap<char,int>::iterator it=ret.first; it!=ret.second; ++it)
      std::cout << ' ' << it->second;
    std::cout << '\n';
  }

  return 0;
}

map和multimap操作总结

文章目录

map

构造函数

赋值运算符

迭代器

容量

emplace函数

操作

find函数

count函数

lower_bound函数

upper_bound函数

equal_range函数

multimap

迭代器

容量

修改

lower_bound函数

upper_bound函数

equal_range函数