C++入门学习——标准模板库之map

map 是 STL 的一个关联容器，它提供一对一（其中第一个可以称为关键字，每个关键字只能在 map 中出现一次，第二个可能称为该关键字的值）的数据处理能力，由于这个特性，它完成有可能在我们处理一对一数据的时候，在编程上提供快速通道。这里简单说一下 map 内部数据的组织，map内部自建一颗红黑树(一种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能，所以在 map 内部所有的数据都是有序的，后边我们会见识到有序的好处。

那什么是一对一的数据映射？比如一个班级中，每个学生的学号跟他的姓名就存在着一一映射的关系，这个模型用 map 可能轻易描述，很明显学号用 int 描述，姓名用字符串描述。

使用 map 之前，必须包含相应的头文件，map 属于 std 命名域的，因此需要通过命名限定：

#include <map>

using std::map; //using namespace std;


1）map 的构造函数

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

map<int, string> mapStudent;

2） 数据的插入

在构造 map 容器后，我们就可以往里面插入数据。这里讲三种插入数据的方法：

a）用 insert 函数插入 pair 数据：

#include <iostream>
#include <map>	//map
#include <string> //string
#include <utility> //pair

using std::endl;
using std::cin;
using std::cout;
using std::map;
using std::string;
using std::pair;
//using namespace std;//或直接把所有都包含

//用insert函数插入pair数据
int main(int argc, char *argv[])
{

	map<int, string> mapStudent;

	//用insert函数插入pair数据
	mapStudent.insert( pair<int, string>(1, "student_one") );
	mapStudent.insert( pair<int, string>(2, "student_two") );
	mapStudent.insert( pair<int, string>(3, "student_three") );

	//通过迭代器遍历map的内容
	map<int, string>::iterator iter;
	for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
	{
	    cout<<iter->first<<" "<<iter->second<<endl;
	}

	return 0;
}

运行结果如下：

b）用 insert 函数插入 value_type 数据：

#include <iostream>
#include <map>	//map pair
#include <string> //string
#include <utility> //pair

using std::endl;
using std::cin;
using std::cout;
using std::map;
using std::string;
using std::pair;
//using namespace std;//或直接把所有都包含

//用insert函数插入value_type数据
int main(int argc, char *argv[])
{

	map<int, string> mapStudent;

	//用insert函数插入value_type数据
	mapStudent.insert( map<int, string>::value_type(1, "student_one") );
	mapStudent.insert( map<int, string>::value_type(2, "student_two") );
	mapStudent.insert( map<int, string>::value_type(3, "student_three") );

	//通过迭代器遍历map的内容
	map<int, string>::iterator iter;
	for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
	{
	    cout<<iter->first<<" "<<iter->second<<endl;
	}

	return 0;
}

c)用数组方式插入数据：

#include <iostream>
#include <map>	//map pair
#include <string> //string

using std::endl;
using std::cin;
using std::cout;
using std::map;
using std::string;
using std::pair;
//using namespace std;//或直接把所有都包含

//用数组方式插入数据
int main(int argc, char *argv[])
{

	map<int, string> mapStudent;

	//用数组方式插入数据
	mapStudent[0] = "student_one";
	mapStudent[2] = "student_two";
	mapStudent[3] = "student_three";

	//通过迭代器遍历map的内容
	map<int, string>::iterator iter;
	for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
	{
	    cout<<iter->first<<" "<<iter->second<<endl;
	}

	return 0;
}

运行结果如下：

以上三种用法，虽然都可以实现数据的插入，但是它们是有区别的。第一种和第二种在效果上是完成一样的，用 insert 函数插入数据，在数据的插入上涉及到集合的唯一性这个概念，即当 map 中已经存在某个关键字时，insert 操作是不能成功插入数据，但是用数组方式则可以，它可以覆盖以前该关键字对应的值。

那我们怎么知道 insert 语句是否插入成功？我们可以用 pair 来获得是否插入成功：

pair< map<int, string>::iterator, bool > insert_pair;
insert_pair = mapStudent.insert( map<int, string>::value_type(1, "student_one") );

我们通过 pair 的第二个变量来判断是否插入成功，它的第一个变量返回的是一个 map 的迭代器，如果插入成功的话 insert_pair.second 为 true，否则为 false。

完整测试代码如下：

#include <iostream>
#include <map>	//map pair
#include <string> //string

using std::endl;
using std::cin;
using std::cout;
using std::map;
using std::string;
using std::pair;
//using namespace std;//或直接把所有都包含

//测试插入是否成功
int main(int argc, char *argv[])
{

	map<int, string> mapStudent;

	pair<map<int, string>::iterator, bool> insert_pair;

	//插入数据
	insert_pair = mapStudent.insert(pair<int, string>(1, "student_one"));
	if(insert_pair.second == true)//插入成功
	{
		cout << "Insert Successfully" << endl;
	}
	else
	{
		cout << "Insert Failure" << endl;
	}

	//插入数据
	insert_pair = mapStudent.insert(pair<int, string>(1, "student_two"));
	if(insert_pair.second == true)//插入成功
	{
		cout << "Insert Successfully" << endl;
	}
	else
	{
		cout << "Insert Failure" << endl;
	}

	cout << "\n------------------------\n";
	//通过迭代器遍历map的内容
	map<int, string>::iterator iter;
	for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
	{
	    cout<<iter->first<<" "<<iter->second<<endl;
	}

	return 0;
}

运行结果如下：

下面示例为测试数组赋值，数据覆盖问题：

#include <iostream>
#include <map>	//map pair
#include <string> //string

using std::endl;
using std::cin;
using std::cout;
using std::map;
using std::string;
using std::pair;
//using namespace std;//或直接把所有都包含

//测试数组赋值，数据覆盖问题
int main(int argc, char *argv[])
{

	map<int, string> mapStudent;

	mapStudent[1] = "student_one";
	mapStudent[1] = "student_two";	//这个也是 1
	mapStudent[2] = "student_three";

	cout << "\n------------------------\n";
	//通过迭代器遍历map的内容
	map<int, string>::iterator iter;
	for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
	{
	    cout<<iter->first<<" "<<iter->second<<endl;
	}

	return 0;
}

运行结果如下：

3）map 的大小

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

int nSize = mapStudent.size();

4）数据的遍历

a）通过前向迭代器，上面举例程序中就是使用此方式。

b）通过反相迭代器：

#include <iostream>
#include <map>	//map pair
#include <string> //string

using std::endl;
using std::cin;
using std::cout;
using std::map;
using std::string;
using std::pair;
//using namespace std;//或直接把所有都包含

//使用反相迭代器遍历map内容
int main(int argc, char *argv[])
{

	map<int, string> mapStudent;

	//用insert函数插入pair数据
	mapStudent.insert( pair<int, string>(1, "student_one") );
	mapStudent.insert( pair<int, string>(2, "student_two") );
	mapStudent.insert( pair<int, string>(3, "student_three") );

	//cout << "\n------------------------\n";
	//使用反相迭代器遍历map内容
	map<int, string>::reverse_iterator iter;
	for(iter = mapStudent.rbegin(); iter != mapStudent.rend(); iter++)
	{
	    cout<<iter->first<<" "<<iter->second<<endl;
	}

	return 0;
}

运行结果如下：

c）通过数组方式：

#include <iostream>
#include <map>	//map pair
#include <string> //string

using std::endl;
using std::cin;
using std::cout;
using std::map;
using std::string;
using std::pair;
//using namespace std;//或直接把所有都包含

//使用数组方式遍历map内容
int main(int argc, char *argv[])
{

	map<int, string> mapStudent;

	//用insert函数插入pair数据
	mapStudent.insert( pair<int, string>(1, "student_one") );
	mapStudent.insert( pair<int, string>(2, "student_two") );
	mapStudent.insert( pair<int, string>(3, "student_three") );

	//cout << "\n------------------------\n";
	//使用数组方式遍历map内容
	int n = mapStudent.size();
	for(int i = 1; i <= n; i++) //从1开始
	{
	    cout<< i << " " << mapStudent[i]<<endl;
	}

	return 0;
}

5）数据的查找

可以使用 find 函数来定位数据出现位置，它返回的一个迭代器，当数据出现时，它返回数据所在位置的迭代器，如果 map 中没有要查找的数据，它返回的迭代器等于 end 函数返回的迭代器。示例代码如下：

#include <iostream>
#include <map>	//map pair
#include <string> //string

using std::endl;
using std::cin;
using std::cout;
using std::map;
using std::string;
using std::pair;
//using namespace std;//或直接把所有都包含

//用find函数来定位数据出现位置
int main(int argc, char *argv[])
{

	map<int, string> mapStudent;

	//用insert函数插入pair数据
	mapStudent.insert( pair<int, string>(1, "student_one") );
	mapStudent.insert( pair<int, string>(2, "student_two") );
	mapStudent.insert( pair<int, string>(3, "student_three") );

	map<int, string>::iterator iter;

	iter = mapStudent.find(1); //查找 1 的内容

	if( iter != mapStudent.end() ) //找到
	{
	    cout << "Find, the value is: "<< iter->second << endl;

	}
	else
	{
	    cout << "Do not Find" << endl;
	}

	return 0;
}

运行结果如下：

6）数据的清空与判空

清空 map 中的数据可以用 clear() 函数，判定 map 中是否有数据可以用 empty() 函数，它返回 true 则说明是空 map。

7）数据的删除

这里要用到 erase 函数，它有三个重载了的函数，下面在例子中详细说明它们的用法：

#include <iostream>
#include <map>	//map pair
#include <string> //string

using std::endl;
using std::cin;
using std::cout;
using std::map;
using std::string;
using std::pair;
//using namespace std;//或直接把所有都包含

//数据的删除
int main(int argc, char *argv[])
{

	map<int, string> mapStudent;

	//用insert函数插入pair数据
	mapStudent.insert( pair<int, string>(0, "student_zero") );
	mapStudent.insert( pair<int, string>(1, "student_one") );
	mapStudent.insert( pair<int, string>(2, "student_two") );
	mapStudent.insert( pair<int, string>(3, "student_three") );
	mapStudent.insert( pair<int, string>(4, "student_four") );

	//如果要删除1,用迭代器删除
	map<int, string>::iterator iter;
	iter = mapStudent.find(1); //先查找1
	mapStudent.erase(iter);

	cout << "\nafter erase 1:\n";
	//通过迭代器遍历map的内容
	for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
	{
	    cout<<iter->first<<" "<<iter->second<<endl;
	}

	//如果要删除2，可用关键字删除
	int n = mapStudent.erase(2);//如果删除成功会返回1，否则返回0
	cout << "n = " << n << endl;

	cout << "\nafter erase 2:\n";
	//通过迭代器遍历map的内容
	for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
	{
	    cout<<iter->first<<" "<<iter->second<<endl;
	}

	//用迭代器，成片的删除
	//成片删除要注意的是，也是STL的特性，删除区间是一个前闭后开的集合
	mapStudent.erase( mapStudent.begin(), mapStudent.end() );

	cout << "\nafter erase all:\n";
	//通过迭代器遍历map的内容
	for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
	{
	    cout<<iter->first<<" "<<iter->second<<endl;
	}

	return 0;
}

运行结果如下：

8）排序

这里要讲的是一点比较高深的用法：排序问题，STL 中默认是采用小于号来排序的，以上代码在排序上是不存在任何问题的，因为上面的关键字是 int 型，它本身支持小于号运算，在一些特殊情况，比如关键字是一个结构体，涉及到排序就会出现问题，因为它没有小于号操作，insert 等函数在编译的时候过不去，测试代码如下：

#include <iostream>
#include <map>	//map pair
#include <string> //string

using std::endl;
using std::cin;
using std::cout;
using std::map;
using std::string;
using std::pair;
//using namespace std;//或直接把所有都包含

typedef struct tagStudentInfo
{
	int nID;
	string strName;
}StudentInfo, *PStudentInfo; //学生信息

//数据的删除
int main(int argc, char *argv[])
{

	//用学生信息映射分数
	map<StudentInfo, int> mapStudent;

	StudentInfo studentInfo;
	studentInfo.nID = 1;
	studentInfo.strName = "student_one";
	mapStudent.insert( pair<StudentInfo, int>(studentInfo, 90) );

	studentInfo.nID = 2;
	studentInfo.strName = "student_two";
	mapStudent.insert( pair<StudentInfo, int>(studentInfo, 80) );

	map<StudentInfo, int>::iterator iter;
	for (iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
	{
		cout<<iter->first.nID<<" "<<iter->first.strName<<" "<<iter->second<<endl;
	}

	return 0;
}

以上程序是无法编译通过的。

解决方法为：重载小于号。示例如下：

#include <iostream>
#include <map>	//map pair
#include <string> //string

using std::endl;
using std::cin;
using std::cout;
using std::map;
using std::string;
using std::pair;
//using namespace std;//或直接把所有都包含

typedef struct tagStudentInfo
{
	int nID;
	string strName;

	bool operator< (tagStudentInfo const &temp) const
	{
		//这个函数指定排序策略，按nID排序，如果nID相等的话，按strName排序
		if(nID < temp.nID)  return true;

		if(nID == temp.nID) return strName.compare(temp.strName);

		return false;
	}

}StudentInfo, *PStudentInfo; //学生信息

//数据的删除
int main(int argc, char *argv[])
{

	//用学生信息映射分数
	map<StudentInfo, int> mapStudent;

	StudentInfo studentInfo;
	studentInfo.nID = 1;
	studentInfo.strName = "student_one";
	mapStudent.insert( pair<StudentInfo, int>(studentInfo, 90) );

	studentInfo.nID = 2;
	studentInfo.strName = "student_two";
	mapStudent.insert( pair<StudentInfo, int>(studentInfo, 80) );

	map<StudentInfo, int>::iterator iter;
	for (iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
	{
		cout<<iter->first.nID<<" "<<iter->first.strName<<" "<<iter->second<<endl;
	}

	return 0;
}

运行结果图如下：

本文转自：http://www.kuqin.com/cpluspluslib

版权声明：本博客文章，大多是本人整理编写，或在网络中收集，转载请注明出处！！

时间： 2024-09-30 05:11:05

C++入门学习——标准模板库之map的相关文章

C++入门学习——标准模板库之vector

vector(向量容器),是 C++ 中十分有用一个容器.vector 之所以被认为是一个容器,是因为它能够像容器一样存放各种类型的对象,简单地说,vector 是一个能够存放任意类型(类型可以是int, double, string, 还可以是类)的动态数组,能够增加和压缩数据. 使用 vector 之前,必须包含相应的头文件,vector 属于 std 命名域的,因此需要通过命名限定: #include <vector> using std::vector; //using namespa

C++ Primer(第五版)学习笔记_1_标准模板库--快速入门

C++ Primer(第五版)学习笔记_1_标准模板库--快速入门 欢迎大家阅读参考,如有错误或疑问请留言纠正,谢谢 标准模板库(STL)提供三种类型的组件:容器.迭代器和算法,他们都支持泛型程序设计标准. 容器主要有两类:顺序容器和关联容器.顺序容器(vector.list.deque和string等)是一系列元素的有序集合.关联容器(set.multiset.map和multimap)包含查找元素的键值. 迭代器的作用是遍历容器. STL算法库包含四类算法:排序算法.不可变序算法.变序性算法

C++标准模板库学习。。。

作为C++标准库相当重要的一部分,STL库提供一系列组件操作.它主要可以分为容器.迭代器.基本算法.函数对象以及内存分配器和配接器六个部分.整个STL库的代码都采用模板函数以及模板类的方式实现,具有高度的通用性.对于传统的应用程序来讲,模板库支持并且倡导一种新的编程风格,即称为泛型编程思想,以通用的模板方式来编写应用程序中的数据结构与算法. 16.1  STL常见容器 C++标准STL库中封装实现了常见数据结构,并以容器的方式提供给用户使用.STL容器主要包含vector向量.deque队列.l

C++ Primer 学习笔记_10_标准模板库_map和set的对比

C++ Primer 学习笔记_10_标准模板库_map和set的对比   set multiset 创建 set<int> str multiset<string> str 插入 str.insert(8) str.insert("abc") 遍历 set<int>::iterator iter multiset< string >::iterator iter 输出 *iter *iter 删除 n = str.erase(8) 删除

C++学习笔记——STL（标准模板库）

1.首先.需要学习C++ 模板的概念 2.C++ STL(标准模板库)是一套功能强大的 C++ 模板类,提供了通用的模板类和函数,这些模板类和函数可以实现多种流行和常用的算法和数据结构,如向量.链表.队列.栈. 3.C++ 标准模板库的核心包括以下三个组件: 组件 描述 容器(Containers) 容器是用来管理某一类对象的集合.C++ 提供了各种不同类型的容器,比如 deque.list.vector.map 等. 算法(Algorithms) 算法作用于容器.它们提供了执行各种操作的方式,

C++ Primer(第五版)学习笔记_9_标准模板库_multimap多重映照容器

C++ Primer(第五版)学习笔记_9_标准模板库_multimap多重映照容器 多重映照容器multimap与map结构基本相同,但由于重复键值存在,所以multimap的元素插入.删除.查找都与map的方法不相同. 1.multimap对象创建.元素插入 插入元素时,需要使用insert()方法和类似pair<string,double>("Jack", 300.5)的元素结构.可以看到,重复的元素是按照插入的先后顺序排序的. #include <iostre

C++ Primer(第五版)学习笔记_8_标准模板库_map映照容器

C++ Primer(第五版)学习笔记_8_标准模板库_map映照容器 map映照容器的元素数据是由一个键值和一个映照数据组成的,键值与映照数据之间具有一一映照的关系. map映照容器的数据结构也是采用红黑树来实现的. 1.map创建.元素插入和遍历访问 #include <iostream> #include <stdio.h> #include <vector> #include <map> #include <string> using n

STL学习一：标准模板库理论基础

STL(Standard Template Library,标准模板库)是惠普实验室开发的一系列软件的统称.现然主要出现在C++中,但在被引入C++之前该技术就已经存在了很长的一段时间. STL的从广义上讲分为三类:algorithm(算法).container(容器)和iterator(迭代器),容器和算法通过迭代器可以进行无缝 地连接.几乎所有的代码都采 用了模板类和模板函数的方式,这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会.在C++标准中,STL被组织为下面的13个头文

C++ Primer 学习笔记_14_标准模板库_bitset位集合容器

C++ Primer 学习笔记_14_标准模板库_bitset位集合容器 bitset容器是一个bit位元素的序列容器,每个元素只占一个bit位,取值为0或1,因而很节省内存空间.下图是一个bitset的存储示意图,它的10个元素只使用了两个字节的空间. 使用bitset需要声明头文件"#include <bitset>" 1.创建bitset对象 创建bitset对象时,必须要指定容器的大小.bitset对象的大小一经定义,就不能修改了.下面这条语句就定义了bitset对