C++中的map用法学习

map是STL的一个关联容器，它提供一对一的hash。

• 第一个可以称为关键字(key)，每个关键字只能在map中出现一次；
• 第二个可能称为该关键字的值(value)；

map以模板(泛型)方式实现，可以存储任意类型的数据，包括使用者自定义的数据类型。Map主要用于资料一对一映射(one-to-one)的情況，map內部的实现自建一颗红黑树，这颗树具有对数据自动排序的功能。在map内部所有的数据都是有序的，后边我们会见识到有序的好处。比如一个班级中，每个学生的学号跟他的姓名就存在著一对一映射的关系。

2，map的功能

自动建立key － value的对应。key 和 value可以是任意你需要的类型，包括自定义类型。

3，使用map

使用map得包含map类所在的头文件

#include <map>  //注意，STL头文件没有扩展名.h

map对象是模板类，需要关键字和存储对象两个模板参数：

std:map<int, string> personnel;

这样就定义了一个用int作为索引,并拥有相关联的指向string的指针.

为了使用方便，可以对模板类进行一下类型定义，

typedef map<int,CString> UDT_MAP_INT_CSTRING;

UDT_MAP_INT_CSTRING enumMap;

4，map的构造函数

map共提供了6个构造函数，这块涉及到内存分配器这些东西，略过不表，在下面我们将接触到一些map的构造方法，这里要说下的就是，我们通常用如下方法构造一个map：

map<int, string> mapStudent;

 map<string , int >mapstring;        map<int ,string >mapint;
   map<sring, char>mapstring;        map< char ,string>mapchar;
   map<char ,int>mapchar;           map<int ,char >mapint；

5，插入元素

// 定义一个map对象
map<int, string> mapStudent;
 
// 第一种 用insert函數插入pair
mapStudent.insert(pair<int, string>(000, "student_zero"));
 
// 第二种 用insert函数插入value_type数据
mapStudent.insert(map<int, string>::value_type(001, "student_one"));
 
// 第三种 用"array"方式插入
mapStudent[123] = "student_first";
mapStudent[456] = "student_second";
以上三种用法，虽然都可以实现数据的插入，但是它们是有区别的，当然了第一种和第二种在效果上是完成一样的，用insert函数插入数据，在数据的 插入上涉及到集合的唯一性这个概念，即当map中有这个关键字时，insert操作是不能在插入数据的，但是用数组方式就不同了，它可以覆盖以前该关键字对 应的值，用程序说明如下：

mapStudent.insert(map<int, string>::value_type (001, "student_one"));
 
mapStudent.insert(map<int, string>::value_type (001, "student_two"));
上面这两条语句执行后，map中001这个关键字对应的值是“student_one”，第二条语句并没有生效，那么这就涉及到我们怎么知道insert语句是否插入成功的问题了，可以用pair来获得是否插入成功，程序如下

// 构造定义，返回一个pair对象
pair<iterator,bool> insert (const value_type& val);
 
pair<map<int, string>::iterator, bool> Insert_Pair;
 
Insert_Pair = mapStudent.insert(map<int, string>::value_type (001, "student_one"));
 
if(!Insert_Pair.second)
    cout << ""Error insert new element" << endl;
我们通过pair的第二个变量来知道是否插入成功，它的第一个变量返回的是一个map的迭代器，如果插入成功的话Insert_Pair.second应该是true的，否则为false。

6， 查找元素

当所查找的关键key出现时，它返回数据所在对象的位置，如果沒有，返回iter与end函数的值相同。

// find 返回迭代器指向当前查找元素的位置否则返回map::end()位置
iter = mapStudent.find("123");
 
if(iter != mapStudent.end())
       cout<<"Find, the value is"<<iter->second<<endl;
else
   cout<<"Do not Find"<<endl;
7， 刪除与清空元素

//迭代器刪除
iter = mapStudent.find("123");
mapStudent.erase(iter);
 
//用关键字刪除
int n = mapStudent.erase("123"); //如果刪除了會返回1，否則返回0
 
//用迭代器范围刪除 : 把整个map清空
mapStudent.erase(mapStudent.begin(), mapStudent.end());
//等同于mapStudent.clear()
8，map的大小

在往map里面插入了数据，我们怎么知道当前已经插入了多少数据呢，可以用size函数，用法如下：

int nSize = mapStudent.size();
 

 9，map的基本操作函数：

     C++ maps是一种关联式容器，包含“关键字/值”对

     begin()         返回指向map头部的迭代器

     clear(）        删除所有元素

     count()         返回指定元素出现的次数

     empty()         如果map为空则返回true

     end()           返回指向map末尾的迭代器

     equal_range()   返回特殊条目的迭代器对

     erase()         删除一个元素

     find()          查找一个元素

     get_allocator() 返回map的配置器

     insert()        插入元素

     key_comp()      返回比较元素key的函数

     lower_bound()   返回键值>=给定元素的第一个位置

     max_size()      返回可以容纳的最大元素个数

     rbegin()        返回一个指向map尾部的逆向迭代器

     rend()          返回一个指向map头部的逆向迭代器

     size()          返回map中元素的个数

     swap()           交换两个map

     upper_bound()    返回键值>给定元素的第一个位置

     value_comp()     返回比较元素value的函数

二. 插入操作

2.1 使用[ ]进行单个插入

map<int, string> ID_Name;

 

// 如果已经存在键值2015，则会作赋值修改操作，如果没有则插入

ID_Name[2015] = "Tom";

 

2.1 使用insert进行单个和多个插入

insert共有4个重载函数：

 

// 插入单个键值对，并返回插入位置和成功标志，插入位置已经存在值时，插入失败

pair<iterator,bool> insert (const value_type& val);

 

//在指定位置插入，在不同位置插入效率是不一样的，因为涉及到重排

iterator insert (const_iterator position, const value_type& val);

 

// 插入多个

void insert (InputIterator first, InputIterator last);

 

//c++11开始支持，使用列表插入多个   

void insert (initializer_list<value_type> il);

 

下面是具体使用示例：

 

#include <iostream>

#include <map>

 

int main()

{

    std::map<char, int> mymap;

 

    // 插入单个值

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

    }

 

    //指定位置插入

    std::map<char, int>::iterator it = mymap.begin();

    mymap.insert(it, std::pair<char, int>('b', 300));  //效率更高

    mymap.insert(it, std::pair<char, int>('c', 400));  //效率非最高

 

    //范围多值插入

    std::map<char, int> anothermap;

    anothermap.insert(mymap.begin(), mymap.find('c'));

 

    // 列表形式插入

    anothermap.insert({ { 'd', 100 }, {'e', 200} });

 

    return 0;

}

 

三. 取值

Map中元素取值主要有at和[ ]两种操作，at会作下标检查，而[]不会。

 

map<int, string> ID_Name;

 

//ID_Name中没有关键字2016，使用[]取值会导致插入

//因此，下面语句不会报错，但打印结果为空

cout<<ID_Name[2016].c_str()<<endl;

 

//使用at会进行关键字检查，因此下面语句会报错

ID_Name.at(2016) = "Bob";

 

四. 容量查询

// 查询map是否为空

bool empty();

 

// 查询map中键值对的数量

size_t size();

 

// 查询map所能包含的最大键值对数量，和系统和应用库有关。

// 此外，这并不意味着用户一定可以存这么多，很可能还没达到就已经开辟内存失败了

size_t max_size();

 

// 查询关键字为key的元素的个数，在map里结果非0即1

size_t count( const Key& key ) const; //

——————————————————————————————————————————————

 

五. 迭代器

共有八个获取迭代器的函数：* begin, end, rbegin,rend* 以及对应的 * cbegin, cend, crbegin,crend*。

 

二者的区别在于，后者一定返回 const_iterator，而前者则根据map的类型返回iterator 或者 const_iterator。const情况下，不允许对值进行修改。如下面代码所示：

 

map<int,int>::iterator it;

map<int,int> mmap;

const map<int,int> const_mmap;

 

it = mmap.begin(); //iterator

mmap.cbegin(); //const_iterator

 

const_mmap.begin(); //const_iterator

const_mmap.cbegin(); //const_iterator

 

返回的迭代器可以进行加减操作，此外，如果map为空，则 begin = end。

 

 

六. 删除交换

6.1 删除

 

// 删除迭代器指向位置的键值对，并返回一个指向下一元素的迭代器

iterator erase( iterator pos )

 

// 删除一定范围内的元素，并返回一个指向下一元素的迭代器

iterator erase( const_iterator first, const_iterator last );

 

// 根据Key来进行删除， 返回删除的元素数量，在map里结果非0即1

size_t erase( const key_type& key );

 

// 清空map，清空后的size为0

void clear();

 

6.2 交换

// 就是两个map的内容互换

void swap( map& other );

 Map中的swap不是一个容器中的元素交换，而是两个容器交换；———————

6.map的sort问题：
  Map中的元素是自动按key升序排序,所以不能对map用sort函数

七. 顺序比较

// 比较两个关键字在map中位置的先后

key_compare key_comp() const;

示例：

map<char,int> mymap;

map<char,int>::key_compare mycomp = mymap.key_comp();

 

mymap['a']=100;

mymap['b']=200;

mycomp('a', 'b');  // a排在b前面，因此返回结果为true

——————————————————————————————————————————————

 

八. 查找

// 关键字查询，找到则返回指向该关键字的迭代器，否则返回指向end的迭代器

// 根据map的类型，返回的迭代器为 iterator 或者 const_iterator

iterator find (const key_type& k);

const_iterator find (const key_type& k) const;

举例：

 

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); // b被成功删除

——————————————————————————————————————————————

 

九. 操作符

operator: == != < <= > >=

注意 对于==运算符, 只有键值对以及顺序完全相等才算成立。

http://blog.sina.com.cn/s/blog_61533c9b0100fa7w.html

https://www.cnblogs.com/yonglin1998/p/11780828.html

 

二. 插入操作

2.1 使用[ ]进行单个插入

map<int, string> ID_Name;

// 如果已经存在键值2015，则会作赋值修改操作，如果没有则插入
ID_Name[2015] = "Tom";

 

• 1
• 2
• 3
• 4

2.1 使用insert进行单个和多个插入

insert共有4个重载函数：

// 插入单个键值对，并返回插入位置和成功标志，插入位置已经存在值时，插入失败
pair<iterator,bool> insert (const value_type& val);

//在指定位置插入，在不同位置插入效率是不一样的，因为涉及到重排
iterator insert (const_iterator position, const value_type& val);

// 插入多个
void insert (InputIterator first, InputIterator last);

//c++11开始支持，使用列表插入多个   
void insert (initializer_list<value_type> il);

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

下面是具体使用示例：

#include <iostream>
#include <map>

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

    // 插入单个值
    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';
    }

    //指定位置插入
    std::map<char, int>::iterator it = mymap.begin();
    mymap.insert(it, std::pair<char, int>('b', 300));  //效率更高
    mymap.insert(it, std::pair<char, int>('c', 400));  //效率非最高

    //范围多值插入
    std::map<char, int> anothermap;
    anothermap.insert(mymap.begin(), mymap.find('c'));

    // 列表形式插入
    anothermap.insert({ { 'd', 100 }, {'e', 200} });

    return 0;
}

• 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
• 29
• 30
• 31
• 32
• 33

——————————————————————————————————————————————

三. 取值

Map中元素取值主要有at和[ ]两种操作，at会作下标检查，而[]不会。

map<int, string> ID_Name;

//ID_Name中没有关键字2016，使用[]取值会导致插入
//因此，下面语句不会报错，但打印结果为空
cout<<ID_Name[2016].c_str()<<endl;

//使用at会进行关键字检查，因此下面语句会报错
ID_Name.at(2016) = "Bob";

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

——————————————————————————————————————————————

四. 容量查询

// 查询map是否为空
bool empty();

// 查询map中键值对的数量
size_t size();

// 查询map所能包含的最大键值对数量，和系统和应用库有关。
// 此外，这并不意味着用户一定可以存这么多，很可能还没达到就已经开辟内存失败了
size_t max_size();

// 查询关键字为key的元素的个数，在map里结果非0即1
size_t count( const Key& key ) const; //

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

——————————————————————————————————————————————

五. 迭代器

共有八个获取迭代器的函数：* begin, end, rbegin,rend* 以及对应的 * cbegin, cend, crbegin,crend*。

二者的区别在于，后者一定返回 const_iterator，而前者则根据map的类型返回iterator 或者 const_iterator。const情况下，不允许对值进行修改。如下面代码所示：

map<int,int>::iterator it;
map<int,int> mmap;
const map<int,int> const_mmap;

it = mmap.begin(); //iterator
mmap.cbegin(); //const_iterator

const_mmap.begin(); //const_iterator
const_mmap.cbegin(); //const_iterator

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

返回的迭代器可以进行加减操作，此外，如果map为空，则 begin = end。

——————————————————————————————————————————————

六. 删除交换

6.1 删除

// 删除迭代器指向位置的键值对，并返回一个指向下一元素的迭代器
iterator erase( iterator pos )

// 删除一定范围内的元素，并返回一个指向下一元素的迭代器
iterator erase( const_iterator first, const_iterator last );

// 根据Key来进行删除， 返回删除的元素数量，在map里结果非0即1
size_t erase( const key_type& key );

// 清空map，清空后的size为0
void clear();

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

6.2 交换

// 就是两个map的内容互换
void swap( map& other );

• 1
• 2

——————————————————————————————————————————————

七. 顺序比较

// 比较两个关键字在map中位置的先后
key_compare key_comp() const;

• 1
• 2

示例：

map<char,int> mymap;
map<char,int>::key_compare mycomp = mymap.key_comp();

mymap['a']=100;
mymap['b']=200;
mycomp('a', 'b');  // a排在b前面，因此返回结果为true

• 1
• 2
• 3
• 4
• 5
• 6

——————————————————————————————————————————————

八. 查找

// 关键字查询，找到则返回指向该关键字的迭代器，否则返回指向end的迭代器
// 根据map的类型，返回的迭代器为 iterator 或者 const_iterator
iterator find (const key_type& k);
const_iterator find (const key_type& k) const;

• 1
• 2
• 3
• 4

举例：

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); // b被成功删除

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

——————————————————————————————————————————————

九. 操作符

operator: == != < <= > >=
注意 对于==运算符, 只有键值对以及顺序完全相等才算成立。