c++ map

•  

• begin()/end()

返回第一个或者最后一个元素的迭代器

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

• clear()

void clear（）;

清楚map中所有元素；

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

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

  mymap['x']=100;
  mymap['y']=200;
  mymap['z']=300;

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

  mymap.clear();
  mymap['a']=1101;
  mymap['b']=2202;

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

  return 0;
}

• count()

size_type count（const key_type＆k）const;

参量

搜索关键字。
成员类型key_type是容器中元素键的类型，在map中定义为其第一个模板参数（Key）的别名

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

•  empty()

返回map是否为空

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

• equal_range()

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

 

•  erase（）

（1）	void erase（迭代器位置）；
（2）	size_type erase（const key_type＆k）;
（3）	void erase（迭代器位置1，迭代器位置2）；

位置

指向要从地图中删除的单个元素的迭代器。
这应指向有效且可取消引用的元素。
成员类型迭代器和const_iterator是指向元素的双向迭代器类型。

ķ

要从地图中删除的元素的键。
成员类型key_type是容器中元素的类型，在map中定义为其第一个模板参数（Key）的别名。

首先，最后

指定要在地图容器中移除的范围的迭代器：[first，last）。即，范围包括first和last之间的所有元素，包括first指向的元素，但last指向不包含的元素。
成员类型迭代器和const_iterator是指向元素的双向迭代器类型。

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

 

• insert()

single element (1)	pair<iterator,bool> insert (const value_type& val);
with hint (2)	iterator insert (iterator position, const value_type& val);
range (3)	template <class InputIterator> void insert (InputIterator first, InputIterator last);

 

值

要复制到（或移动为）插入元素的值。
成员类型value_type是容器中元素的类型，在映射中定义为对 <const key_type，mapped_type>（请参见映射成员类型）。

模板参数P应为可转换为value_type的类型。

如果将P实例化为引用类型，则将复制参数。

位置

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

 

如果 位置指向将 在插入元素 之前的元素，则该函数将优化其插入时间。

请注意，这只是一个提示，并且不强制在范围内的位置上插入新元素的地图容器（在元素地图始终遵循这取决于他们的关键特定的顺序）。
成员类型迭代器和const_iterator在map中定义为指向元素的双向迭代器类型。

首先，最后

指定元素范围的迭代器。范围为[first，last）的元素副本插入到容器中。
请注意，范围包括first和last之间的所有元素，包括first所指向的元素，而不是last所指向的元素。
函数模板参数InputIterator必须是一个输入迭代器类型，该类型指向可以从其构造value_type对象的类型的元素。

il

一个initializer_list对象。插入这些元素的副本。
这些对象是根据初始值设定项列表声明符自动构造的。
成员类型value_type是容器中包含的元素的类型，在映射中定义为对 <const key_type，mapped_type>（请参见映射成员类型）。

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

• size()

返回map 的大小

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

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