C++中的map用法学习

zoukankan html css js c++ java

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

}

//指定位置插入

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

    //指定位置插入
    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: == != < <= > >=
注意对于==运算符, 只有键值对以及顺序完全相等才算成立。
查看全文

相关阅读:
WWF中关于External Data Exchange Service的错误
 通用异常处理框架(转载)
追MM和23种设计模式（转载）
编译：XAML与程序代码结合（转载）
异步编程*（转载）
出糗~又是工作流！
由WorkflowOwnershipException 异常，联想出的部署犯案
 Nullable类型，C#溢出检查，typeof运算符和运算符的重载分类： C# 20121028 19:50 648人阅读评论(0) 收藏
 我的程序员之路（九）参加郑州微软MVP宣讲会后的一些思考
 C#结构的学习

原文地址：https://www.cnblogs.com/klb561/p/13831382.html

C++中的map用法学习

二. 插入操作

2.1 使用[ ]进行单个插入

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

三. 取值

四. 容量查询

五. 迭代器

六. 删除交换

6.1 删除

6.2 交换

七. 顺序比较

八. 查找

九. 操作符