初识C++ · map和set的使用

目录

前言：

1 set

2 map

---

前言：

在前面阶段，我们已经学习了stl里面的部分容器，比如vector,list,deque等，这些容器都被称为序列式容器，也就是每个值之间式没有关联的，那么今天介绍的容器，map和set，是关联式容器，即每个值之间是有关联的，关联式容器在数据存储方面和序列式容器没有什么大差别，但是在数据检索上就很有用了，其中map的key - value模型存的键值对在数据检索方面的效率是很高的。

上篇介绍了二叉搜索树，当数据接近有序的时候，二叉搜索树的效率就比较低了，接近logN了，那么map和set就是基于红黑树实现的一种结构，它在普通二叉树的基础上加成了平衡。

话不多说，开始介绍。

---

1 set

set的底层模型是key模型，即每个节点只有一个类型的值，我们先看定义：

set的模板参数有3个，第一个是key_type，也就是每个值的类型，compare是仿函数，这个点在优先级队列有提及，第三个参数是空间配置器，基本stl的容器都是人手一个。

左边注释的那些，都是被typedof的，文档解释如下：

现在我们进入到set的成员函数部分。

有关构造 析构 赋值

第一个构造函数，是默认构造函数，不需要传参，我们可以理解为，空构造，第二个构造函数，是迭代器区间构造，我们可以使用其他容器的迭代器来进行构造，第三个构造就是拷贝构造了：

int main()
{
	vector<int> v1({ 1,2,3,4 });
	set<int> s1;
	set<int> s2(v1.begin(), v1.end());

	return 0;
}

析构没有什么要注意的，set支持直接赋值的，所以可以：

int main()
{
	vector<int> v1({ 1,2,3,4 });
	set<int> s1;
	set<int> s2(v1.begin(), v1.end());
	s1 = s2;

	return 0;
}

有关迭代器部分

如文档解释的iterator一样，set支持的是双向迭代器，所以有begin，就有rbegin，cbegin也是不可少的，crbegin也有，使用方面上和vector那些没有什么差别：

int main()
{
	vector<int> v1({ 1,2,3,4 });
	set<int> s1;
	set<int> s2(v1.begin(), v1.end());
	s1 = s2;

	set<int>::iterator it1 = s2.begin();
	while (it1 != s2.end())
	{
		cout << *it1 << " " << endl;
        it1++;
	}
	cout << endl;

	return 0;
}

但是这是set，set是key模型，也就意味着我们想要修改里面的值的时候，就会报错：

有关capacity部分

无非就是判断是否为空，大小多少，最大的空间开辟都到多少，使用和序列式容器一样的，就不多介绍了。

有关Modifiers部分

这里面的emplace和insert的作用差不多的，留到C++ 11里面介绍，因为里面涉及到了右值引用。

与序列式容器不同的是，这没有头插尾插，只有一个insert，删除也是同理，因为结构的特性，insert erase使用如下：

int main()
{
	set<int> s1;
    s1.insert(1);
    s1.insert(2);
    s1.insert(3);
    s1.insert(3);
    s1.insert(4);

    s1.erase(1);
    s1.erase(2);
    s1.erase(3);
    s1.erase(18);
	return 0;
}

有人发现不对了吧，插入有问题吗？没有问题，但是有个问题需要注意，请问插入了两个3，里面有几个3呢？在二叉搜索树的模拟实现中，就提及到了，不允许数据的冗余性，但是呢，这是也是不会报错的，同理，在模拟实现删除的时候，删除失败就会返回false，这里也是同理，所以都不会报错：

int main()
{
	set<int> s1;
	s1.insert(1);
	s1.insert(2);
	s1.insert(3);
	s1.insert(3);
	s1.insert(4);

	set<int>::iterator it1 = s1.begin();
	while (it1 != s1.end())
	{
		cout << *it1 << " " << endl;
		it1++;
	}
	cout << endl;

	s1.erase(1);
	s1.erase(2);
	s1.erase(3);
	s1.erase(18);

	set<int>::iterator it2 = s1.begin();
	while (it2 != s1.end())
	{
		cout << *it2 << " " << endl;
		it2++;
	}
	cout << endl;
	return 0;
}

最后都是可以正常打印：

有关operations部分

 这里介绍find count lower_bound upper_bound:

find的返回值是iterator，也就是返回的那个值的迭代器，我们就可以用于删除，或者是遍历，删除也可以用迭代器来删除，是erase的第二个重载：

int main()
{
	set<int> s1{ 1,2,3,4,5,6,7,8 };
	set<int>::iterator it1 = s1.find(3);
	set<int>::iterator it2 = s1.find(8);
	s1.erase(it2);
	while (it1 != s1.end())
	{
		cout << *it1 << endl;
		it1++;
	}
	
	return 0;
}

count的使用也就是计数了，但是因为不允许数据的冗余，每个值顶多只有一个，所以count的值不是1就是0，那也是有作用的：

int main()
{
	set<int> s1{ 1,2,3,4,5,6,7,8 };
	if (s1.count(1) == 1)
	{
		cout << "s1里面有1这个元素" << endl;
	}
	return 0;
}

这就是count的使用。

对于lower_bound upper_bound 的使用，它们是经常在一起使用的，它们形成的是一个左闭右开的区间，和迭代器的使用保持一致，左闭右开：

int main()
{
	std::set<int> myset;
	std::set<int>::iterator itlow, itup;

	for (int i = 1; i < 10; i++)
		myset.insert(i * 10); 

	itlow = myset.lower_bound(30);
	itup = myset.upper_bound(60);

	myset.erase(itlow, itup);

	std::cout << "myset contains:";
	for (std::set<int>::iterator it = myset.begin(); it != myset.end(); ++it)
		std::cout << ' ' << *it;

	return 0;
}

所以最终打印就是把30 - 60的部分删除了，但是这里返回的迭代器一定不是60，是70。

对于set来说，数据冗余是不允许的，但是有特定的容器允许：

即multiset，multi是多样的意思，这个容器除了允许数据冗余之外，没有其他更改。

---

2 map

map是key - value模型：

可以看到模板参数有4个，其中有key T 仿函数和空间配置器。

那么有了set的铺垫，这里我们就选几个函数来介绍：

在map里面，我们着重需要注意的是insert和[]重载，先来看insert:

insert的第一个重载就是涉及到了pair<iterator,bool>，那么什么是pair呢？

pair有两个参数，而在key - value模型中，我们实现的时候是使用定义两个变量的方法，实际操作的时候是使用的pair参数，我们将key - value存放pair里面，简称为键值对。

在stl里面关于pair的定义如下：

template <class T1, class T2>
struct pair
{
typedef T1 first_type;
typedef T2 second_type;
T1 first;
T2 second;
pair(): first(T1()), second(T2())
{}
pair(const T1& a, const T2& b): first(a), second(b)
{}
};

有一个first 一个second ，我们存放map的时候，first就是key，second就是value。

那么插入可以：

int main()
{
	map<int,int> m1;
	pair<int, int> kv1(1,2);
	m1.insert(kv1);
	return 0;
}

也可以：

	m1.insert(pair<int,int>(1, 4));

但是呢，创建一个有名对象和一个匿名对象都有人觉得麻烦了，于是有这么一个方法：

make_pair方法，返回值是一个pair类型，我们可以直接使用该函数来插入：

m1.insert(make_pair(2, 4));

 但是还是麻烦了，对于多参数类型的构造函数来讲，我们可以直接隐式类型转换：

m1.insert({ 2, 4 });

 这里可不是initializer_list的使用，因为pair的参数有两个，构造需要两个参数，对于多参数的构造函数来讲直接隐式构造就可以了，这里可不是vector的构造。

但是呢，initializer_list可以用到map的构造里面去，这种构造是在C++11里面才引入的：

map<string, string> m2{ {"left","左边"}, {"right","右边"}, {"Hello","你好"}, {"main","主要的"}};

这种构造也是被允许的，和vector的构造是一样的。

对于operator[]：

这个可是个大头，在vector里面，[]是下标随机访问的函数，在这里，只能说有一点点像，具体我们先看最下面的那段代码，函数等效于：

(*((this->insert(make_pair(k,mapped_type()))).first)).second

我们从里面看，make_pair是创建一个键值对，里面的参数是k,mapped_type，其实第二个参数不给的话就是空构造，但是K是有的。简单翻译就是插入first，返回second。

同时我们根据文档可以看到，返回值是mapp_type的引用，也就是键值对的second的引用，此时，我们再看看insert的文档：

在insert的返回值，我们可以看到这段话，简单翻译过来就是，键值对的第二个参数是bool类型的，插入成功，bool值就会变成true类型，如果插入失败，即结构里面已经有了该key，bool类型就会变成false类型，但是无论如何，键值对的第一个参数，迭代器类型都会指向所在key的迭代器或者是新插入的key的所在的迭代器类型，那么简单模拟实现一下就是：

V& operator[](const T& key)
{
	pair<iterator, bool> ret = insert(make_pair(key, V()));
	iterator it = ret.first;
	return ret->second;
}

返回的值是第二个参数的引用，也就是说间接可以修改第二个参数了，这点还是很不错的，但是如果我们不使用返回值，可以相当于插入使用，所以[]的使用可以：

int main()
{
	map<string, string> m2{ {"left","左边"}, {"right","右边"}, {"Hello","你好"}, {"main","主要的"}};
	m2["world"];
	return 0;
}

这是一种插入，但是基本上不这么用。

int main()
{
	map<string, string> m2{ {"left","左边"}, {"right","右边"}, {"Hello","你好"}, {"main","主要的"}};
	m2["Hello"] = "哈喽";
	return 0;
}

这是一种修改。

int main()
{
	map<string, string> m2{ {"left","左边"}, {"right","右边"}, {"Hello","你好"}, {"main","主要的"}};
	m2["Hello"] = "哈喽";
	cout << m2["Hello"] << endl;
	return 0;
}

这是一种查找。

总结来说可以实现的操作可以有查找，修改，插入 + 修改，毕竟如果key有的话也不会插入，就相当于修改了。

[]的使用是很厉害的，可能有人会觉得和vector的使用有点像，但差了很多，自行体会哈哈哈。

当然，这里也有multimap，和set那边是一样的，下来可以自己试试。

总结：

set + map的使用可以当去重，因为插入多个数据的时候，不会插入多个数据，也可以用来排序，也可以用来求差集，交集，这点都是因为set 和 map没有数据的冗余。

---

感谢阅读！