技术标签: 2024年程序员学习 学习 c++ 笔记
先自我介绍一下,小编浙江大学毕业,去过华为、字节跳动等大厂,目前阿里P7
深知大多数程序员,想要提升技能,往往是自己摸索成长,但自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年最新Golang全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上Go语言开发知识点,真正体系化!
由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新
如果你需要这些资料,可以添加V获取:vip1024b (备注go)
}
程序执行结果为:
Python教程 http://c.biancheng.net/python/
STL教程 http://c.biancheng.net/stl/
注意,程序中第 9 行代码已经为 map 容器添加了一个以 “STL教程” 作为键的键值对,则第 11 行代码的作用就变成了修改该键对应的值,而不再是为 map 容器添加新键值对。
举个例子:
#include
#include
程序执行结果为:
http://c.biancheng.net/c/
程序第 12 行代码处,通过 myMap 容器调用 at() 成员方法,可以成功找到键为 “C语言教程” 的键值对,并返回该键对应的值;而第 14 行代码,由于当前 myMap 容器中没有以 “Python教程” 为键的键值对,会导致 at() 成员方法查找失败,并抛出 out_of_range 异常。
除了可以直接获取指定键对应的值之外,还可以借助 find() 成员方法间接实现此目的。和以上 2 种方式不同的是,该方法返回的是一个迭代器,即如果查找成功,该迭代器指向查找到的键值对;反之,则指向 map 容器最后一个键值对之后的位置(和 end() 成功方法返回的迭代器一样)。
举个例子:
#include
#include
程序执行结果为:
C语言教程 http://c.biancheng.net/c/
注意,此程序中如果 find() 查找失败,会导致第 13 行代码运行出错。因为当 find() 方法查找失败时,其返回的迭代器指向的是容器中最后一个键值对之后的位置,即不指向任何有意义的键值对,也就没有所谓的 first 和 second 成员了。
如果以上方法都不适用,我们还可以遍历整个 map 容器,找到包含指定键的键值对,进而获取该键对应的值。比如:
#include
#include
程序执行结果为:
C语言教程 http://c.biancheng.net/c/
本节所介绍的几种方法中,仅从“在 map 容器存储的键值对中,获取指定键对应的值”的角度出发,更推荐使用 at() 成员方法,因为该方法既简单又安全。
前面讲过,C++ STL map 类模板中对[ ]
运算符进行了重载,即根据使用场景的不同,借助[ ]
运算符可以实现不同的操作。举个例子:
#include
#include
return 0;
}
程序执行结果为:
http://c.biancheng.net/java/
Python教程 http://c.biancheng.net/python/
STL教程 http://c.biancheng.net/stl/
可以看到,当操作对象为 map 容器中已存储的键值对时,则借助 [ ] 运算符,既可以获取指定键对应的值,还能对指定键对应的值进行修改;反之,若 map 容器内部没有存储以 [ ] 运算符内指定数据为键的键值对,则使用 [ ] 运算符会向当前 map 容器中添加一个新的键值对。
实际上,除了使用 [ ] 运算符实现向 map 容器中添加新键值对外,map 类模板中还提供有 insert() 成员方法,该方法专门用来向 map 容器中插入新的键值对。
注意,这里所谓的“插入”,指的是 insert() 方法可以将新的键值对插入到 map 容器中的指定位置,但这与 map 容器会自动对存储的键值对进行排序并不冲突。当使用 insert() 方法向 map 容器的指定位置插入新键值对时,其底层会先将新键值对插入到容器的指定位置,如果其破坏了 map 容器的有序性,该容器会对新键值对的位置进行调整。
自 C++ 11 标准后,insert() 成员方法的用法大致有以下 4 种。
//1、引用传递一个键值对
pair<iterator,bool> insert (const value_type& val);
//2、以右值引用的方式传递键值对
template
pair<iterator,bool> insert (P&& val);
其中,val 参数表示键值对变量,同时该方法会返回一个 pair 对象,其中 pair.first 表示一个迭代器,pair.second 为一个 bool 类型变量:
以上 2 种语法格式的区别在于传递参数的方式不同,即无论是局部定义的键值对变量还是全局定义的键值对变量,都采用普通引用传递的方式;而对于临时的键值对变量,则以右值引用的方式传参。有关右值引用,可阅读《C++右值引用》一文做详细了解。
举个例子:
#include
#include
//创建一个真实存在的键值对变量
std::pair<string, string> STL = { “STL教程”,“http://c.biancheng.net/stl/” };
//创建一个接收 insert() 方法返回值的 pair 对象
std::pair<std::map<string, string>::iterator, bool> ret;
//插入 STL,由于 STL 并不是临时变量,因此会以第一种方式传参
ret = mymap.insert(STL);
cout << “ret.iter = <{” << ret.first->first << ", " << ret.first->second << "}, " << ret.second << “>” << endl;
//以右值引用的方式传递临时的键值对变量
ret = mymap.insert({ “C语言教程”,“http://c.biancheng.net/c/” });
cout << “ret.iter = <{” << ret.first->first << ", " << ret.first->second << "}, " << ret.second << “>” << endl;
//插入失败样例
ret = mymap.insert({ “STL教程”,“http://c.biancheng.net/java/” });
cout << “ret.iter = <{” << ret.first->first << ", " << ret.first->second << "}, " << ret.second << “>” << endl;
return 0;
}
程序执行结果为:
ret.iter = <{STL教程, http://c.biancheng.net/stl/}, 1>
ret.iter = <{C语言教程, http://c.biancheng.net/c/}, 1>
ret.iter = <{STL教程, http://c.biancheng.net/stl/}, 0>
从执行结果中不难看出,程序中共执行了 3 次插入操作,其中成功了 2 次,失败了 1 次:
另外,在程序中的第 21 行代码,还可以使用如下 2 种方式创建临时的键值对变量,它们是等价的:
//调用 pair 类模板的构造函数
ret = mymap.insert(pair<string,string>{ “C语言教程”,“http://c.biancheng.net/c/” });
//调用 make_pair() 函数
ret = mymap.insert(make_pair(“C语言教程”, “http://c.biancheng.net/c/”));
//以普通引用的方式传递 val 参数
iterator insert (const_iterator position, const value_type& val);
//以右值引用的方式传递 val 键值对参数
template
iterator insert (const_iterator position, P&& val);
其中 val 为要插入的键值对变量。注意,和第 1 种方式的语法格式不同,这里 insert() 方法返回的是迭代器,而不再是 pair 对象:
举个例子:
#include
#include
//创建一个真实存在的键值对变量
std::pair<string, string> STL = { “STL教程”,“http://c.biancheng.net/stl/” };
//指定要插入的位置
std::map<string, string>::iterator it = mymap.begin();
//向 it 位置以普通引用的方式插入 STL
auto iter1 = mymap.insert(it, STL);
cout << iter1->first << " " << iter1->second << endl;
//向 it 位置以右值引用的方式插入临时键值对
auto iter2 = mymap.insert(it, std::pair<string, string>(“C语言教程”, “http://c.biancheng.net/c/”));
cout << iter2->first << " " << iter2->second << endl;
//插入失败样例
auto iter3 = mymap.insert(it, std::pair<string, string>(“STL教程”, “http://c.biancheng.net/java/”));
cout << iter3->first << " " << iter3->second << endl;
return 0;
}
程序执行结果为:
STL教程 http://c.biancheng.net/stl/
C语言教程 http://c.biancheng.net/c/
STL教程 http://c.biancheng.net/stl/
再次强调,即便指定了新键值对的插入位置,map 容器仍会对存储的键值对进行排序。也可以说,决定新插入键值对位于 map 容器中位置的,不是 insert() 方法中传入的迭代器,而是新键值对中键的值。
template
void insert (InputIterator first, InputIterator last);
其中 first 和 last 都是迭代器,它们的组合<first,last>
可以表示某 map 容器中的指定区域。
举个例子:
#include
#include
程序执行结果为:
Java教程 http://c.biancheng.net/java/
STL教程 http://c.biancheng.net/stl/
此程序中,<first,last> 指定的区域是从 mumap 容器第 2 个键值对开始,之后所有的键值对,所以 copymap 容器中包含有 2 个键值对。
void insert ({val1, val2, …});
其中,vali 都表示的是键值对变量。
举个例子:
#include
#include
程序执行结果为:
C语言教程 http://c.biancheng.net/c/
Java教程 http://c.biancheng.net/java/
STL教程 http://c.biancheng.net/stl/
值得一提的是,除了 insert() 方法,map 类模板还提供 emplace() 和 emplace_hint() 方法,它们也可以完成向 map 容器中插入键值对的操作,且效率还会 insert() 方法高。关于这 2 个方法,会在下一节做详细介绍。
通过前面的学习我们知道,map 容器模板类中提供有 operator[ ] 和 insert() 这 2 个成员方法,而值得一提的是,这 2 个方法具有相同的功能,它们既可以实现向 map 容器中添加新的键值对元素,也可以实现更新(修改)map 容器已存储键值对的值。
举个例子(程序一):
#include
#include
程序执行结果为:
old mymap:http://c.biancheng.net/java/
new mymap:http://c.biancheng.net/stl/
old ret.iter = <{Java教程, http://c.biancheng.net/python/}, 1>
new ret.iter = <Java教程, http://c.biancheng.net/java/>
有关程序中 operator[ ] 和 insert() 成员方法的具体用法,读者可翻阅前面的文章做详细了解,这里不再做过多解释。
显然,map 模板类中 operator[ ] 和 insert() 的功能发生了重叠,这就产生了一个问题,谁的执行效率更高呢?
总的来说,读者可记住这样一条结论:当实现“向 map 容器中添加新键值对元素”的操作时,insert() 成员方法的执行效率更高;而在实现“更新 map 容器指定键值对的值”的操作时,operator[ ] 的效率更高。
至于为什么,有兴趣的读者可继续往下阅读。
首先解释一下,为什么实现向 map 容器中添加新键值对元素,insert() 方法的执行效率比 operator[ ] 更高?回顾程序一中,如下语句完成了向空 mymap 容器添加新的键值对元素:
mymap[“STL教程”] = “http://c.biancheng.net/java/”;
此行代码中,mymap[“STL教程”] 实际上是 mymap.operator 的缩写(底层调用的 operator[ ] 方法),该方法会返回一个指向 “STL教程” 对应的 value 值的引用。
但需要注意的是,由于此时 mymap 容器是空的,并没有 “STL教程” 对应的 value 值。这种情况下,operator[ ] 方法会默认构造一个 string 对象,并将其作为 “STL教程” 对应的 value 值,然后返回一个指向此 string 对象的引用。在此基础上,代码还会将 “http://c.biancheng.net.java/” 赋值给这个 string 对象。
也就是说,上面这行代码的执行流程,可以等效为如下程序:
typedef map<string, string> mstr;
//创建要添加的默认键值对元素
pair<mstr::iterator, bool>res = mymap.insert(mstr::value_type(“STL教程”, string()));
//将新键值对的值赋值为指定的值
res.first->second = “http://c.biancheng.net/java/”;
注意,这里的 value_type(K,T) 指的是 map 容器中存储元素的类型,其实际上就等同于 pair<K,T>。
可以看到,使用 operator[ ] 添加新键值对元素的流程是,先构造一个有默认值的键值对,然后再为其 value 赋值。
那么,为什么不直接构造一个要添加的键值对元素呢,比如:
mymap.insert(mstr::value_type(“STL教程”, “http://c.biancheng.net/java/”));
此行代码和上面程序的执行效果完全相同,但它省略了创建临时 string 对象的过程以及析构该对象的过程,同时还省略了调用 string 类重载的赋值运算符。由于可见,同样是完成向 map 容器添加新键值对,insert() 方法比 operator[ ] 的执行效率更高。
仍以程序一中的代码为例,如下分别是 operator[ ] 和 insert() 实现更新 mymap 容器中指定键对应的值的代码:
//operator[]
mymap[“STL教程”] = “http://c.biancheng.net/stl/”;
//insert()
std::pair<string, string> STL = { “Java教程”,“http://c.biancheng.net/python/” };
mymap.insert(STL).first->second = “http://c.biancheng.net/java/”;
仅仅从语法形式本身来考虑,或许已经促使很多读者选择 operator[ ] 了。接下来,我们再从执行效率的角度对比以上 2 种实现方式。
从上面代码可以看到,insert() 方法在进行更新操作之前,需要有一个 pair 类型(也就是 map::value_type 类型)元素做参数。这意味着,该方法要多构造一个 pair 对象(附带要构造 2 个 string 对象),并且事后还要析构此 pair 对象(附带 2 个 string 对象的析构)。
而和 insert() 方法相比,operator[ ] 就不需要使用 pair 对象,自然不需要构造(并析构)任何 pair 对象或者 string 对象。因此,对于更新已经存储在 map 容器中键值对的值,应优先使用 operator[ ] 方法。
学习 map insert() 方法时提到,C++ STL map 类模板中还提供了 emplace() 和 emplace_hint() 成员函数,也可以实现向 map 容器中插入新的键值对。本节就来讲解这 2 个成员方法的用法。
值得一提的是,实现相同的插入操作,无论是用 emplace() 还是 emplace_hont(),都比 insert() 方法的效率高(后续章节会详细讲解)。
和 insert() 方法相比,emplace() 和 emplace_hint() 方法的使用要简单很多,因为它们各自只有一种语法格式。其中,emplace() 方法的语法格式如下:
template <class… Args>
pair<iterator,bool> emplace (Args&&… args);
参数 (Args&&… args) 指的是,这里只需要将创建新键值对所需的数据作为参数直接传入即可,此方法可以自行利用这些数据构建出指定的键值对。另外,该方法的返回值也是一个 pair 对象,其中 pair.first 为一个迭代器,pair.second 为一个 bool 类型变量:
下面程序演示 emplace() 方法的具体用法:
#include
#include
程序执行结果为:
1、ret.iter = <{STL教程, http://c.biancheng.net/stl/}, 1>
2、ret.iter = <{C语言教程, http://c.biancheng.net/c/}, 1>
3、ret.iter = <{STL教程, http://c.biancheng.net/stl/}, 0>
可以看到,程序中共执行了 3 次向 map 容器插入键值对的操作,其中前 2 次都成功了,第 3 次由于要插入的键值对的键和 map 容器中已存在的键值对的键相同,因此插入失败。
emplace_hint() 方法的功能和 emplace() 类似,其语法格式如下:
template <class… Args>
iterator emplace_hint (const_iterator position, Args&&… args);
显然和 emplace() 语法格式相比,有以下 2 点不同:
下面程序演示 emplace_hint() 方法的用法:
#include
#include
程序执行结果为:
STL教程 http://c.biancheng.net/stl/
C语言教程 http://c.biancheng.net/c/
STL教程 http://c.biancheng.net/stl/
注意,和 insert() 方法一样,虽然 emplace_hint() 方法指定了插入键值对的位置,但 map 容器为了保持存储键值对的有序状态,可能会移动其位置。
那么,为什么 emplace() 和 emplace_hint() 方法的执行效率,比 insert() 高呢?下一节会做详细解释。
上一节在学习 C++STL map 容器的 emplace() 和 emplace_hint() 的基本用法时,还遗留了一个问题,即为什么 emplace() 和 emplace_hint() 的执行效率会比 insert() 高?
原因很简单,它们向 map 容器插入键值对时,底层的实现方式不同:
也就是说,向 map 容器中插入键值对时,emplace() 和 emplace_hint() 方法都省略了移动键值对的过程,因此执行效率更高。下面程序提供了有利的证明:
#include
#include
cout << “emplace():” << endl;
mymap.emplace( “http://c.biancheng.net/stl/:”, 1);
cout << “emplace_hint():” << endl;
mymap.emplace_hint(mymap.begin(), “http://c.biancheng.net/stl/”, 1);
return 0;
}
程序输出结果为:
insert():
调用构造函数
调用移动构造函数
调用移动构造函数
emplace():
调用构造函数
emplace_hint():
调用构造函数
分析一下这个程序。首先,我们创建了一个存储 <string,tempDemo> 类型键值对的空 map 容器,接下来分别用 insert()、emplace() 和 emplace_hint() 方法向该 map 容器中插入相同的键值对。
从输出结果可以看出,在使用 insert() 方法向 map 容器插入键值对时,整个插入过程调用了 1 次 tempDemo 类的构造函数,同时还调用了 2 次移动构造函数。实际上,程序第 28 行代码底层的执行过程,可以分解为以下 3 步:
//构造类对象
testDemo val = testDemo(1); //调用 1 次构造函数
//构造键值对
auto pai = make_pair(“http://c.biancheng.net/stl/”, val); //调用 1 次移动构造函数
//完成插入操作
mymap.insert(pai); //调用 1 次移动构造函数
而完成同样的插入操作,emplace() 和 emplace_hint() 方法都只调用了 1 次构造函数,这足以证明,这 2 个方法是在 map 容器内部直接构造的键值对。
因此,在实现向 map 容器中插入键值对时,应优先考虑使用 emplace() 或者 emplace_hint()。
在掌握 C++ STL map 容器的基础上,本节再讲一个和 map 相似的关联式容器,即 multimap 容器。
所谓“相似”,指的是 multimap 容器具有和 map 相同的特性,即 multimap 容器也用于存储 pair<const K, T> 类型的键值对(其中 K 表示键的类型,T 表示值的类型),其中各个键值对的键的值不能做修改;并且,该容器也会自行根据键的大小对存储的所有键值对做排序操作。和 map 容器的区别在于,multimap 容器中可以同时存储多(≥2)个键相同的键值对。
和 map 容器一样,实现 multimap 容器的类模板也定义在<map>
头文件,并位于 std 命名空间中。因此,在使用 multimap 容器前,程序应包含如下代码:
#include
using namespace std;
注意,第二行代码不是必需的,但若不用,则程序中在使用 multimap 容器时需手动注明 std 命名空间(强烈建议初学者使用)。
multimap 容器类模板的定义如下:
template < class Key, // 指定键(key)的类型
class T, // 指定值(value)的类型
class Compare = less, // 指定排序规则
class Alloc = allocator<pair<const Key,T> > // 指定分配器对象的类型
class multimap;
可以看到,multimap 容器模板有 4 个参数,其中后 2 个参数都设有默认值。
大多数场景中,我们只需要设定前 2 个参数的值,有些场景可能会用到第 3 个参数,但最后一个参数几乎不会用到。
multimap 类模板内部提供有多个构造函数,总的来说,创建 multimap 容器的方式可归为以下 5 种。
std::multimap<std::string, std::string>mymultimap;
如果程序中已经默认指定了 std 命令空间,这里可以省略 std::。
//创建并初始化 multimap 容器
multimap<string, string>mymultimap{ {“C语言教程”, “http://c.biancheng.net/c/”},
{“Python教程”, “http://c.biancheng.net/python/”},
{“STL教程”, “http://c.biancheng.net/stl/”} };
注意,使用此方式初始化 multimap 容器时,其底层会先将每一个{key, value}
创建成 pair 类型的键值对,然后再用已建好的各个键值对初始化 multimap 容器。
实际上,我们完全可以先手动创建好键值对,然后再用其初始化 multimap 容器。下面程序使用了 2 种方式创建 pair 类型键值对,再用其初始化 multimap 容器,它们是完全等价的:
//借助 pair 类模板的构造函数来生成各个pair类型的键值对
multimap<string, string>mymultimap{
pair<string,string>{“C语言教程”, “http://c.biancheng.net/c/”},
pair<string,string>{ “Python教程”, “http://c.biancheng.net/python/”},
pair<string,string>{ “STL教程”, “http://c.biancheng.net/stl/”}
};
//调用 make_pair() 函数,生成键值对元素
//创建并初始化 multimap 容器
multimap<string, string>mymultimap{
make_pair(“C语言教程”, “http://c.biancheng.net/c/”),
make_pair(“Python教程”, “http://c.biancheng.net/python/”),
make_pair(“STL教程”, “http://c.biancheng.net/stl/”)
};
multimap<string, string>newmultimap(mymultimap);
由此,就成功创建一个和 mymultimap 完全一样的 newmultimap 容器。
在 C++ 11 标准中,还为 multimap 类增添了移动构造函数。即当有临时的 multimap 容器作为参数初始化新 multimap 容器时,其底层就会调用移动构造函数来实现初始化操作。举个例子:
//创建一个会返回临时 multimap 对象的函数
multimap<string, string> dismultimap() {
multimap<string, string>tempmultimap{ {“C语言教程”, “http://c.biancheng.net/c/”},{“Python教程”, “http://c.biancheng.net/python/”} };
return tempmultimap;
}
//调用 multimap 类模板的移动构造函数创建 newMultimap 容器
multimap<string, string>newmultimap(dismultimap());
上面程序中,由于 dismultimap() 函数返回的 tempmultimap 容器是一个临时对象,因此在实现初始化 newmultimap 容器时,底层调用的是 multimap 容器的移动构造函数,而不再是拷贝构造函数。
注意,无论是调用复制构造函数还是调用拷贝构造函数,都必须保证这 2 个容器的类型完全一致。
//创建并初始化 multimap 容器
multimap<string, string>mymultimap{ {“C语言教程”, “http://c.biancheng.net/c/”},
{“Python教程”, “http://c.biancheng.net/python/”},
{“STL教程”, “http://c.biancheng.net/stl/”} };
multimap<string, string>newmultimap(++mymultimap.begin(), mymultimap.end());
这里使用了 multimap 容器的迭代器,选取了 mymultimap 容器中的最后 2 个键值对,用于初始化 newmultimap 容器。
multimap 容器迭代器,和 map 容器迭代器的用法完全相同,这里不再赘述。
std::less<T>
,这意味着以下 2 种创建 multimap 容器的方式是等价的:multimap<char, int>mymultimap{ {‘a’,1},{‘b’,2} };
multimap<char, int, std::less>mymultimap{ {‘a’,1},{‘b’,2} };
mymultimap 容器中键值对的存储顺序为:
<a,1>
<b,2>
下面程序利用了 STL 模板库提供的std::greater<T>
排序函数,实现令 multimap 容器对存储的键值对做降序排序:
multimap<char, int, std::greater>mymultimap{ {‘a’,1},{‘b’,2} };
其内部键值对的存储顺序为:
<b,2>
<a,1>
在某些特定场景中,我们还可以为 multimap 容器自定义排序规则,此部分知识后续将利用整整一节做重点讲解。
表 1 列出了 multimap 类模板提供的常用成员方法及各自的功能。
成员方法 | 功能 |
---|---|
begin() | 返回指向容器中第一个(注意,是已排好序的第一个)键值对的双向迭代器。如果 multimap 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
end() | 返回指向容器最后一个元素(注意,是已排好序的最后一个)所在位置后一个位置的双向迭代器,通常和 begin() 结合使用。如果 multimap 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
rbegin() | 返回指向最后一个(注意,是已排好序的最后一个)元素的反向双向迭代器。如果 multimap 容器用 const 限定,则该方法返回的是 const 类型的反向双向迭代器。 |
rend() | 返回指向第一个(注意,是已排好序的第一个)元素所在位置前一个位置的反向双向迭代器。如果 multimap 容器用 const 限定,则该方法返回的是 const 类型的反向双向迭代器。 |
cbegin() | 和 begin() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的键值对。 |
cend() | 和 end() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的键值对。 |
crbegin() | 和 rbegin() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的键值对。 |
crend() | 和 rend() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的键值对。 |
find(key) | 在 multimap 容器中查找首个键为 key 的键值对,如果成功找到,则返回指向该键值对的双向迭代器;反之,则返回和 end() 方法一样的迭代器。另外,如果 multimap 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
lower_bound(key) | 返回一个指向当前 multimap 容器中第一个大于或等于 key 的键值对的双向迭代器。如果 multimap 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
upper_bound(key) | 返回一个指向当前 multimap 容器中第一个大于 key 的键值对的迭代器。如果 multimap 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
equal_range(key) | 该方法返回一个 pair 对象(包含 2 个双向迭代器),其中 pair.first 和 lower_bound() 方法的返回值等价,pair.second 和 upper_bound() 方法的返回值等价。也就是说,该方法将返回一个范围,该范围中包含的键为 key 的键值对。 |
empty() | 若容器为空,则返回 true;否则 false。 |
size() | 返回当前 multimap 容器中存有键值对的个数。 |
max_size() | 返回 multimap 容器所能容纳键值对的最大个数,不同的操作系统,其返回值亦不相同。 |
insert() | 向 multimap 容器中插入键值对。 |
erase() | 删除 multimap 容器指定位置、指定键(key)值或者指定区域内的键值对。 |
swap() | 交换 2 个 multimap 容器中存储的键值对,这意味着,操作的 2 个键值对的类型必须相同。 |
clear() | 清空 multimap 容器中所有的键值对,使 multimap 容器的 size() 为 0。 |
emplace() | 在当前 multimap 容器中的指定位置处构造新键值对。其效果和插入键值对一样,但效率更高。 |
emplace_hint() | 在本质上和 emplace() 在 multimap 容器中构造新键值对的方式是一样的,不同之处在于,使用者必须为该方法提供一个指示键值对生成位置的迭代器,并作为该方法的第一个参数。 |
count(key) | 在当前 multimap 容器中,查找键为 key 的键值对的个数并返回。 |
和 map 容器相比,multimap 未提供 at() 成员方法,也没有重载 [] 运算符。这意味着,map 容器中通过指定键获取指定指定键值对的方式,将不再适用于 multimap 容器。其实这很好理解,因为 multimap 容器中指定的键可能对应多个键值对,而不再是 1 个。
另外值的一提的是,由于 multimap 容器可存储多个具有相同键的键值对,因此表 1 中的 lower_bound()、upper_bound()、equal_range() 以及 count() 成员方法会经常用到。
下面例子演示了表 1 中部分成员方法的用法:
#include
#include
程序执行结果为:
4
2
a 10
b 20
b 15
c 30
注意,只要是 multimap 容器提供的成员方法,map 容器都提供,并且它们的用法是相同的。前面章节中已经对 map 容器提供的成员方法做了详细的讲解,因此这里不再对表 1 中其它的成员方法做详细的介绍。
前面章节讲解了 map 容器和 multimap 容器的用法,类似地,C++ STL 标准库中还提供有 set 和 multiset 这 2 个容器,它们也属于关联式容器。不过,本节先讲解 set 容器,后续章节再讲解 multiset 容器。
和 map、multimap 容器不同,使用 set 容器存储的各个键值对,要求键 key 和值 value 必须相等。
举个例子,如下有 2 组键值对数据:
{<‘a’, 1>, <‘b’, 2>, <‘c’, 3>}
{<‘a’, ‘a’>, <‘b’, ‘b’>, <‘c’, ‘c’>}
显然,第一组数据中各键值对的键和值不相等,而第二组中各键值对的键和值对应相等。对于 set 容器来说,只能存储第 2 组键值对,而无法存储第一组键值对。
基于 set 容器的这种特性,当使用 set 容器存储键值对时,只需要为其提供各键值对中的 value 值(也就是 key 的值)即可。仍以存储上面第 2 组键值对为例,只需要为 set 容器提供 {‘a’,‘b’,‘c’} ,该容器即可成功将它们存储起来。
通过前面的学习我们知道,map、multimap 容器都会自行根据键的大小对存储的键值对进行排序,set 容器也会如此,只不过 set 容器中各键值对的键 key 和值 value 是相等的,根据 key 排序,也就等价为根据 value 排序。
另外,使用 set 容器存储的各个元素的值必须各不相同。更重要的是,从语法上讲 set 容器并没有强制对存储元素的类型做 const 修饰,即 set 容器中存储的元素的值是可以修改的。但是,C++ 标准为了防止用户修改容器中元素的值,对所有可能会实现此操作的行为做了限制,使得在正常情况下,用户是无法做到修改 set 容器中元素的值的。
对于初学者来说,切勿尝试直接修改 set 容器中已存储元素的值,这很有可能破坏 set 容器中元素的有序性,最正确的修改 set 容器中元素值的做法是:先删除该元素,然后再添加一个修改后的元素。
值得一提的是,set 容器定义于<set>
头文件,并位于 std 命名空间中。因此如果想在程序中使用 set 容器,该程序代码应先包含如下语句:
#include
using namespace std;
注意,第二行代码不是必需的,如果不用,则后续程序中在使用 set 容器时,需手动注明 std 命名空间(强烈建议初学者使用)。
set 容器的类模板定义如下:
template < class T, // 键 key 和值 value 的类型
class Compare = less, // 指定 set 容器内部的排序规则
class Alloc = allocator // 指定分配器对象的类型
class set;
注意,由于 set 容器存储的各个键值对,其键和值完全相同,也就意味着它们的类型相同,因此 set 容器类模板的定义中,仅有第 1 个参数用于设定存储数据的类型。
对于 set 类模板中的 3 个参数,后 2 个参数自带默认值,且几乎所有场景中只需使用前 2 个参数,第 3 个参数不会用到。
常见的创建 set 容器的方法,大致有以下 5 种。
std::setstd::string myset;
如果程序中已经默认指定了 std 命令空间,这里可以省略 std::。
由此就创建好了一个 set 容器,该容器采用默认的std::less<T>
规则,会对存储的 string 类型元素做升序排序。注意,由于 set 容器支持随时向内部添加新的元素,因此创建空 set 容器的方法是经常使用的。
std::setstd::string myset{“http://c.biancheng.net/java/”,
“http://c.biancheng.net/stl/”,
“http://c.biancheng.net/python/”};
由此即创建好了包含 3 个 string 元素的 myset 容器。由于其采用默认的 std::less 规则,因此其内部存储 string 元素的顺序如下所示:
“http://c.biancheng.net/java/”
“http://c.biancheng.net/python/”
“http://c.biancheng.net/stl/”
例如,在第 2 种方式创建的 myset 容器的基础上,执行如下代码:
std::setstd::string copyset(myset);
//等同于
//std::setstd::string copyset = myset
该行代码在创建 copyset 容器的基础上,还会将 myset 容器中存储的所有元素,全部复制给 copyset 容器一份。
另外,C++ 11 标准还为 set 类模板新增了移动构造函数,其功能是实现创建新 set 容器的同时,利用临时的 set 容器为其初始化。比如:
set retSet() {
std::setstd::string myset{ “http://c.biancheng.net/java/”,
“http://c.biancheng.net/stl/”,
“http://c.biancheng.net/python/” };
return myset;
}
std::setstd::string copyset(retSet());
//或者
//std::setstd::string copyset = retSet();
注意,由于 retSet() 函数的返回值是一个临时 set 容器,因此在初始化 copyset 容器时,其内部调用的是 set 类模板中的移动构造函数,而非拷贝构造函数。
显然,无论是调用复制构造函数还是调用拷贝构造函数,都必须保证这 2 个容器的类型完全一致。
std::setstd::string myset{ “http://c.biancheng.net/java/”,
“http://c.biancheng.net/stl/”,
“http://c.biancheng.net/python/” };
std::setstd::string copyset(++myset.begin(), myset.end());
由此初始化的 copyset 容器,其内部仅存有如下 2 个 string 字符串:
“http://c.biancheng.net/python/”
“http://c.biancheng.net/stl/”
std::less<T>
规则。其实,借助 set 类模板定义中第 2 个参数,我们完全可以手动修改 set 容器中的排序规则。比如:std::set<std::string,std::greater > myset{ “http://c.biancheng.net/java/”, “http://c.biancheng.net/stl/”, “http://c.biancheng.net/python/”};
通过选用 std::greater 降序规则,myset 容器中元素的存储顺序为:
“http://c.biancheng.net/stl/”
“http://c.biancheng.net/python/”
“http://c.biancheng.net/java/”
表 1 列出了 set 容器提供的常用成员方法以及各自的功能。
成员方法 | 功能 |
---|---|
begin() | 返回指向容器中第一个(注意,是已排好序的第一个)元素的双向迭代器。如果 set 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
end() | 返回指向容器最后一个元素(注意,是已排好序的最后一个)所在位置后一个位置的双向迭代器,通常和 begin() 结合使用。如果 set 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
rbegin() | 返回指向最后一个(注意,是已排好序的最后一个)元素的反向双向迭代器。如果 set 容器用 const 限定,则该方法返回的是 const 类型的反向双向迭代器。 |
rend() | 返回指向第一个(注意,是已排好序的第一个)元素所在位置前一个位置的反向双向迭代器。如果 set 容器用 const 限定,则该方法返回的是 const 类型的反向双向迭代器。 |
cbegin() | 和 begin() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的元素值。 |
cend() | 和 end() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的元素值。 |
crbegin() | 和 rbegin() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的元素值。 |
crend() | 和 rend() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的元素值。 |
find(val) | 在 set 容器中查找值为 val 的元素,如果成功找到,则返回指向该元素的双向迭代器;反之,则返回和 end() 方法一样的迭代器。另外,如果 set 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
lower_bound(val) | 返回一个指向当前 set 容器中第一个大于或等于 val 的元素的双向迭代器。如果 set 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
upper_bound(val) | 返回一个指向当前 set 容器中第一个大于 val 的元素的迭代器。如果 set 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
equal_range(val) | 该方法返回一个 pair 对象(包含 2 个双向迭代器),其中 pair.first 和 lower_bound() 方法的返回值等价,pair.second 和 upper_bound() 方法的返回值等价。也就是说,该方法将返回一个范围,该范围中包含的值为 val 的元素(set 容器中各个元素是唯一的,因此该范围最多包含一个元素)。 |
empty() | 若容器为空,则返回 true;否则 false。 |
size() | 返回当前 set 容器中存有元素的个数。 |
max_size() | 返回 set 容器所能容纳元素的最大个数,不同的操作系统,其返回值亦不相同。 |
insert() | 向 set 容器中插入元素。 |
erase() | 删除 set 容器中存储的元素。 |
swap() | 交换 2 个 set 容器中存储的所有元素。这意味着,操作的 2 个 set 容器的类型必须相同。 |
clear() | 清空 set 容器中所有的元素,即令 set 容器的 size() 为 0。 |
emplace() | 在当前 set 容器中的指定位置直接构造新元素。其效果和 insert() 一样,但效率更高。 |
emplace_hint() | 在本质上和 emplace() 在 set 容器中构造新元素的方式是一样的,不同之处在于,使用者必须为该方法提供一个指示新元素生成位置的迭代器,并作为该方法的第一个参数。 |
count(val) | 在当前 set 容器中,查找值为 val 的元素的个数,并返回。注意,由于 set 容器中各元素的值是唯一的,因此该函数的返回值最大为 1。 |
下面程序演示了表 1 中部分成员函数的用法:
#include
#include
#include
using namespace std;
int main()
{
//创建空set容器
std::setstd::string myset;
//空set容器不存储任何元素
cout << "1、myset size = " << myset.size() << endl;
//向myset容器中插入新元素
myset.insert(“http://c.biancheng.net/java/”);
myset.insert(“http://c.biancheng.net/stl/”);
myset.insert(“http://c.biancheng.net/python/”);
cout << "2、myset size = " << myset.size() << endl;
//利用双向迭代器,遍历myset
for (auto iter = myset.begin(); iter != myset.end(); ++iter) {
cout << *iter << endl;
}
return 0;
}
程序执行结果为:
1、myset size = 0
2、myset size = 3
http://c.biancheng.net/java/
http://c.biancheng.net/python/
http://c.biancheng.net/stl/
有关表 1 中其它成员方法的用法,后续章节会做详细讲解。
和 map 容器不同,C++ STL 中的 set 容器类模板中未提供 at() 成员函数,也未对 [] 运算符进行重载。因此,要想访问 set 容器中存储的元素,只能借助 set 容器的迭代器。
值得一提的是,C++ STL 标准库为 set 容器配置的迭代器类型为双向迭代器。这意味着,假设 p 为此类型的迭代器,则其只能进行 ++p、p++、–p、p–、*p 操作,并且 2 个双向迭代器之间做比较,也只能使用 == 或者 != 运算符。
在 set 容器类模板提供的所有成员函数中,返回迭代器的成员函数如表 1 所示。
成员方法 | 功能 |
---|---|
begin() | 返回指向容器中第一个(注意,是已排好序的第一个)元素的双向迭代器。如果 set 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
end() | 返回指向容器最后一个元素(注意,是已排好序的最后一个)所在位置后一个位置的双向迭代器,通常和 begin() 结合使用。如果 set 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
rbegin() | 返回指向最后一个(注意,是已排好序的最后一个)元素的反向双向迭代器。如果 set 容器用 const 限定,则该方法返回的是 const 类型的反向双向迭代器。 |
rend() | 返回指向第一个(注意,是已排好序的第一个)元素所在位置前一个位置的反向双向迭代器。通常和 rbegin() 结合使用。如果 set 容器用 const 限定,则该方法返回的是 const 类型的反向双向迭代器。 |
cbegin() | 和 begin() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的元素值。 |
cend() | 和 end() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的元素值。 |
crbegin() | 和 rbegin() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的元素值。 |
crend() | 和 rend() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的元素值。 |
find(val) | 在 set 容器中查找值为 val 的元素,如果成功找到,则返回指向该元素的双向迭代器;反之,则返回和 end() 方法一样的迭代器。另外,如果 set 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
lower_bound(val) | 返回一个指向当前 set 容器中第一个大于或等于 val 的元素的双向迭代器。如果 set 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
upper_bound(val) | 返回一个指向当前 set 容器中第一个大于 val 的元素的迭代器。如果 set 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
equal_range(val) | 该方法返回一个 pair 对象(包含 2 个双向迭代器),其中 pair.first 和 lower_bound() 方法的返回值等价,pair.second 和 upper_bound() 方法的返回值等价。也就是说,该方法将返回一个范围,该范围中包含的值为 val 的元素(set 容器中各个元素是唯一的,因此该范围最多包含一个元素)。 |
注意,以上成员函数返回的迭代器,指向的只是 set 容器中存储的元素,而不再是键值对。另外,以上成员方法返回的迭代器,无论是 const 类型还是非 const 类型,都不能用于修改 set 容器中的值。
图 2 演示了表 1 中除最后 4 个成员函数外,其它几个成员函数的具体功能。
图 2 set容器迭代器功能示意图
其中,Ei 表示 set 容器中存储的各个元素,它们的值各不相同。
下面程序以 begin()/end() 为例,演示了如何使用图 2 中相关迭代器遍历 set 容器:
#include
#include
#include
using namespace std;
int main()
{
//创建并初始化set容器
std::setstd::string myset{ “http://c.biancheng.net/java/”,
“http://c.biancheng.net/stl/”,
“http://c.biancheng.net/python/”
};
//利用双向迭代器,遍历myset
for (auto iter = myset.begin(); iter != myset.end(); ++iter) {
cout << *iter << endl;
}
return 0;
}
程序执行结果为:
http://c.biancheng.net/java/
http://c.biancheng.net/python/
http://c.biancheng.net/stl/
再次强调,正如程序第 15 行代码所示的那样,因为 iter 迭代器指向的是 set 容器存储的某个元素,而不是键值对,因此通过 *iter 可以直接获取该迭代器指向的元素的值。
除此之外,如果只想遍历 set 容器中指定区域内的部分数据,则可以借助 find()、lower_bound() 以及 upper_bound() 实现。通过调用它们,可以获取一个指向指定元素的迭代器。
需要特别指出的是,equal_range(val) 函数的返回值是一个 pair 类型数据,其包含 2 个迭代器,表示 set 容器中和指定参数 val 相等的元素所在的区域,但由于 set 容器中存储的元素各不相等,因此该函数返回的这 2 个迭代器所表示的范围中,最多只会包含 1 个元素。
举个例子:
#include
#include
#include
using namespace std;
int main()
{
//创建并初始化set容器
std::setstd::string myset{ “http://c.biancheng.net/java/”,
“http://c.biancheng.net/stl/”,
“http://c.biancheng.net/python/”
};
set::iterator iter = myset.find(“http://c.biancheng.net/python/”);
for (;iter != myset.end();++iter)
{
cout << *iter << endl;
}
return 0;
}
程序执行结果为:
http://c.biancheng.net/python/
http://c.biancheng.net/stl/
值得一提的是,虽然 C++ STL 标准中,set 类模板中包含 lower_bound()、upper_bound()、equal_range() 这 3 个成员函数,但它们更适用于 multiset 容器,几乎不会用于操作 set 容器。
通过前面的学习,我们已经学会如何创建一个 set 容器。在此基础上,如果想向 set 容器中继续添加元素,可以借助 set 类模板提供的 insert() 方法。
为满足不同场景的需要,C++ 11 标准的 set 类模板中提供了多种不同语法格式的 insert() 成员方法,它们各自的功能和用法如下所示。
//普通引用方式传参
pair<iterator,bool> insert (const value_type& val);
//右值引用方式传参
pair<iterator,bool> insert (value_type&& val);
其中,val 表示要添加的新元素,该方法的返回值为 pair 类型。
以上 2 种格式的区别仅在于传递参数的方式不同,即第一种采用普通引用的方式传参,而第二种采用右值引用的方式传参。右值引用为 C++ 11 新添加的一种引用方式,可阅读《C++ 右值引用》一文做详细了解。
可以看到,以上 2 种语法格式的 insert() 方法,返回的都是 pair 类型的值,其包含 2 个数据,一个迭代器和一个 bool 值:
举个例子:
#include
#include
#include
using namespace std;
int main()
{
//创建并初始化set容器
std::setstd::string myset;
//准备接受 insert() 的返回值
pair<set::iterator, bool> retpair;
//采用普通引用传值方式
string str = “http://c.biancheng.net/stl/”;
retpair = myset.insert(str);
cout << “iter->” << *(retpair.first) << " " << "bool = " << retpair.second << endl;
//采用右值引用传值方式
retpair = myset.insert(“http://c.biancheng.net/python/”);
cout << “iter->” << *(retpair.first) << " " << "bool = " << retpair.second << endl;
return 0;
}
程序执行结果为:
iter->http://c.biancheng.net/stl/ bool = 1
iter->http://c.biancheng.net/python/ bool = 1
通过观察输出结果不难看出,程序中两次借助 insert() 方法向 set 容器中添加元素,都成功了。
//以普通引用的方式传递 val 值
iterator insert (const_iterator position, const value_type& val);
//以右值引用的方式传递 val 值
iterator insert (const_iterator position, value_type&& val);
以上 2 种语法格式中,insert() 函数的返回值为迭代器:
举个例子:
#include
#include
#include
using namespace std;
int main()
{
//创建并初始化set容器
std::setstd::string myset;
//准备接受 insert() 的返回值
set::iterator iter;
//采用普通引用传值方式
string str = “http://c.biancheng.net/stl/”;
iter = myset.insert(myset.begin(),str);
cout << “myset size =” << myset.size() << endl;
//采用右值引用传值方式
iter = myset.insert(myset.end(),“http://c.biancheng.net/python/”);
cout << “myset size =” << myset.size() << endl;
return 0;
}
程序执行结果为:
myset size =1
myset size =2
注意,使用 insert() 方法将目标元素插入到 set 容器指定位置后,如果该元素破坏了容器内部的有序状态,set 容器还会自行对新元素的位置做进一步调整。也就是说,insert() 方法中指定新元素插入的位置,并不一定就是该元素最终所处的位置。
insert() 方法的语法格式如下:
template
void insert (InputIterator first, InputIterator last);
其中 first 和 last 都是迭代器,它们的组合 [first,last) 可以表示另一 set 容器中的一块区域,该区域包括 first 迭代器指向的元素,但不包含 last 迭代器指向的元素。
举个例子:
#include
#include
#include
using namespace std;
int main()
{
//创建并初始化set容器
std::setstd::string myset{ “http://c.biancheng.net/stl/”,
“http://c.biancheng.net/python/”,
“http://c.biancheng.net/java/” };
//创建一个同类型的空 set 容器
std::setstd::string otherset;
//利用 myset 初始化 otherset
otherset.insert(++myset.begin(), myset.end());
//输出 otherset 容器中的元素
for (auto iter = otherset.begin(); iter != otherset.end(); ++iter) {
cout << *iter << endl;
}
return 0;
}
程序执行结果为:
http://c.biancheng.net/python/
http://c.biancheng.net/stl/
注意,程序第 15 行在初始化 otherset 容器时,选取的是 myset 容器中从第 2 个元素开始(包括此元素)直到容器末尾范围内的所有元素,所以程序输出结果中只有 2 个字符串。
void insert ( {E1, E2,…,En} );
其中,Ei 表示新添加的元素。
举个例子:
#include
#include
#include
using namespace std;
int main()
{
//创建并初始化set容器
std::setstd::string myset;
//向 myset 中添加多个元素
myset.insert({ “http://c.biancheng.net/stl/”,
“http://c.biancheng.net/python/”,
“http://c.biancheng.net/java/” });
for (auto iter = myset.begin(); iter != myset.end(); ++iter) {
cout << *iter << endl;
}
return 0;
}
程序执行结果为:
http://c.biancheng.net/java/
http://c.biancheng.net/python/
http://c.biancheng.net/stl/
以上的讲解,即为 set 类模板中 insert() 成员方法的全部用法。指的一提的是,C++ 11 标准的 set 类模板中,还提供有另外 2 个成员方法,分别为 implace() 和 implace_hint() 方法,借助它们不但能实现向 set 容器添加新元素的功能,其实现效率也比 insert() 成员方法更高。
有关 set 类模板中 implace() 和 implace_hint() 方法的用法,后续章节会做详细介绍。
如果想删除 set 容器存储的元素,可以选择用 erase() 或者 clear() 成员方法。
set 类模板中,erase() 方法有 3 种语法格式,分别如下:
//删除 set 容器中值为 val 的元素
size_type erase (const value_type& val);
//删除 position 迭代器指向的元素
iterator erase (const_iterator position);
//删除 [first,last) 区间内的所有元素
iterator erase (const_iterator first, const_iterator last);
其中,第 1 种格式的 erase() 方法,其返回值为一个整数,表示成功删除的元素个数;后 2 种格式的 erase() 方法,返回值都是迭代器,其指向的是 set 容器中删除元素之后的第一个元素。
注意,如果要删除的元素就是 set 容器最后一个元素,则 erase() 方法返回的迭代器就指向新 set 容器中最后一个元素之后的位置(等价于 end() 方法返回的迭代器)。
下面程序演示了以上 3 种 erase() 方法的用法:
#include
#include
#include
using namespace std;
int main()
{
//创建并初始化 set 容器
std::setmyset{1,2,3,4,5};
cout << "myset size = " << myset.size() << endl;
//1) 调用第一种格式的 erase() 方法
int num = myset.erase(2); //删除元素 2,myset={1,3,4,5}
cout << "1、myset size = " << myset.size() << endl;
cout << "num = " << num << endl;
//2) 调用第二种格式的 erase() 方法
set::iterator iter = myset.erase(myset.begin()); //删除元素 1,myset={3,4,5}
cout << "2、myset size = " << myset.size() << endl;
cout << “iter->” << *iter << endl;
//3) 调用第三种格式的 erase() 方法
set::iterator iter2 = myset.erase(myset.begin(), --myset.end());//删除元素 3,4,myset={5}
cout << "3、myset size = " << myset.size() << endl;
cout << “iter2->” << *iter2 << endl;
return 0;
}
程序执行结果为:
myset size = 5
1、myset size = 4
num = 1
2、myset size = 3
iter->3
3、myset size = 1
iter2->5
如果需要删除 set 容器中存储的所有元素,可以使用 clear() 成员方法。该方法的语法格式如下:
void clear();
显然,该方法不需要传入任何参数,也没有任何返回值。
举个例子:
#include
#include
#include
using namespace std;
int main()
{
//创建并初始化 set 容器
std::setmyset{1,2,3,4,5};
cout << "1、myset size = " << myset.size() << endl;
//清空 myset 容器
myset.clear();
cout << "2、myset size = " << myset.size() << endl;
return 0;
}
程序执行结果为:
1、myset size = 5
2、myset size = 0
前面章节中,对 set 容器做了详细的讲解。回忆一下,set 容器具有以下几个特性:
在此基础上,C++ STL 标准库中还提供有一个和 set 容器相似的关联式容器,即 multiset 容器。所谓“相似”,是指 multiset 容器遵循 set 容器的前 3 个特性,仅在第 4 条特性上有差异。和 set 容器不同的是,multiset 容器可以存储多个值相同的元素。
也就是说,multiset 容器和 set 容器唯一的差别在于,multiset 容器允许存储多个值相同的元素,而 set 容器中只能存储互不相同的元素。
和 set 类模板一样,multiset 类模板也定义在<set>
头文件,并位于 std 命名空间中。这意味着,如果想在程序中使用 multiset 容器,该程序代码应包含如下语句:
#include
using namespace std;
注意,第二行代码不是必需的,如果不用,则后续程序中在使用 multiset容器时,需手动注明 std 命名空间(强烈建议初学者使用)。
multiset 容器类模板的定义如下所示:
template < class T, // 存储元素的类型
class Compare = less, // 指定容器内部的排序规则
class Alloc = allocator > // 指定分配器对象的类型
class multiset;
显然,multiset 类模板有 3 个参数,其中后 2 个参数自带有默认值。值得一提的是,在实际使用中,我们最多只需要使用前 2 个参数即可,第 3 个参数不会用到。
创建 multiset 容器,无疑需要调用 multiset 类模板中的构造函数。值得一提的是,multiset 类模板提供的构造函数,和 set 类模板中提供创建 set 容器的构造函数,是完全相同的。这意味着,创建 set 容器的方式,也同样适用于创建 multiset 容器。
考虑到一些读者可能并未系统学习 set 容器,因此这里还是对 multiset 容器的创建做一下详细的介绍。
multiset 类模板中提供了 5 种构造函数,也就代表有 5 种创建 multiset 容器的方式,分别如下。
std::multisetstd::string mymultiset;
如果程序中已经默认指定了 std 命令空间,这里可以省略 std::。
由此就创建好了一个 mymultiset 容器,该容器采用默认的std::less<T>
规则,会对存储的 string 类型元素做升序排序。
注意,由于 multiset 容器支持随时向内部添加新的元素,因此创建空 multiset 容器的方法比较常用。
2)除此之外,multiset 类模板还支持在创建 multiset 容器的同时,对其进行初始化。例如:
std::multisetstd::string mymultiset{ “http://c.biancheng.net/java/”,
“http://c.biancheng.net/stl/”,
“http://c.biancheng.net/python/” };
由此即创建好了包含 3 个 string 元素的 mymultiset 容器。由于其采用默认的std::less<T>
规则,因此其内部存储 string 元素的顺序如下所示:
“http://c.biancheng.net/java/”
“http://c.biancheng.net/python/”
“http://c.biancheng.net/stl/”
例如,在第 2 种方式创建的 mymultiset 容器的基础上,执行如下代码:
std::multisetstd::string copymultiset(mymultiset);
//等同于
//std::multisetstd::string copymultiset = mymultiset;
该行代码在创建 copymultiset 容器的基础上,还会将 mymultiset 容器中存储的所有元素,全部复制给 copymultiset 容器一份。
另外,C++ 11 标准还为 multiset 类模板新增了移动构造函数,其功能是实现创建新 multiset 容器的同时,利用临时的 multiset 容器为其初始化。比如:
multiset retMultiset() {
std::multisetstd::string tempmultiset{ “http://c.biancheng.net/java/”,
“http://c.biancheng.net/stl/”,
“http://c.biancheng.net/python/” };
return tempmultiset;
}
std::multisetstd::string copymultiset(retMultiset());
//等同于
//std::multisetstd::string copymultiset = retMultiset();
注意,由于 retMultiset() 函数的返回值是一个临时 multiset 容器,因此在初始化 copymultiset 容器时,其内部调用的是 multiset 类模板中的移动构造函数,而非拷贝构造函数。
显然,无论是调用复制构造函数还是调用拷贝构造函数,都必须保证这 2 个容器的类型完全一致。
std::multisetstd::string mymultiset{ “http://c.biancheng.net/java/”,
“http://c.biancheng.net/stl/”,
“http://c.biancheng.net/python/” };
std::setstd::string copymultiset(++mymultiset.begin(), mymultiset.end());
以上初始化的 copyset 容器,其内部仅存有如下 2 个 string 字符串:
“http://c.biancheng.net/python/”
“http://c.biancheng.net/stl/”
std::less<T>
规则。其实,借助 multiset 类模板定义中的第 2 个参数,我们完全可以手动修改 multiset 容器中的排序规则。下面样例中,使用了 STL 标准库提供的 std::greater 排序方法,作为 multiset 容器内部的排序规则:
std::multiset<std::string, std::greater > mymultiset{
“http://c.biancheng.net/java/”,
“http://c.biancheng.net/stl/”,
“http://c.biancheng.net/python/” };
通过选用std::greater<string>
降序规则,mymultiset 容器中元素的存储顺序为:
“http://c.biancheng.net/stl/”
“http://c.biancheng.net/python/”
“http://c.biancheng.net/java/”
multiset 容器提供的成员方法,和 set 容器提供的完全一样,如表 1 所示。
成员方法 | 功能 |
---|---|
begin() | 返回指向容器中第一个(注意,是已排好序的第一个)元素的双向迭代器。如果 multiset 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
end() | 返回指向容器最后一个元素(注意,是已排好序的最后一个)所在位置后一个位置的双向迭代器,通常和 begin() 结合使用。如果 multiset 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
rbegin() | 返回指向最后一个(注意,是已排好序的最后一个)元素的反向双向迭代器。如果 multiset 容器用 const 限定,则该方法返回的是 const 类型的反向双向迭代器。 |
rend() | 返回指向第一个(注意,是已排好序的第一个)元素所在位置前一个位置的反向双向迭代器。如果 multiset 容器用 const 限定,则该方法返回的是 const 类型的反向双向迭代器。 |
cbegin() | 和 begin() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的元素值。 |
cend() | 和 end() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的元素值。 |
crbegin() | 和 rbegin() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的元素值。 |
crend() | 和 rend() 功能相同,只不过在其基础上,增加了 const 属性,不能用于修改容器内存储的元素值。 |
find(val) | 在 multiset 容器中查找值为 val 的元素,如果成功找到,则返回指向该元素的双向迭代器;反之,则返回和 end() 方法一样的迭代器。另外,如果 multiset 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
lower_bound(val) | 返回一个指向当前 multiset 容器中第一个大于或等于 val 的元素的双向迭代器。如果 multiset 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
upper_bound(val) | 返回一个指向当前 multiset 容器中第一个大于 val 的元素的迭代器。如果 multiset 容器用 const 限定,则该方法返回的是 const 类型的双向迭代器。 |
equal_range(val) | 该方法返回一个 pair 对象(包含 2 个双向迭代器),其中 pair.first 和 lower_bound() 方法的返回值等价,pair.second 和 upper_bound() 方法的返回值等价。也就是说,该方法将返回一个范围,该范围中包含所有值为 val 的元素。 |
empty() | 若容器为空,则返回 true;否则 false。 |
size() | 返回当前 multiset 容器中存有元素的个数。 |
max_size() | 返回 multiset 容器所能容纳元素的最大个数,不同的操作系统,其返回值亦不相同。 |
insert() | 向 multiset 容器中插入元素。 |
erase() | 删除 multiset 容器中存储的指定元素。 |
swap() | 交换 2 个 multiset 容器中存储的所有元素。这意味着,操作的 2 个 multiset 容器的类型必须相同。 |
clear() | 清空 multiset 容器中所有的元素,即令 multiset 容器的 size() 为 0。 |
emplace() | 在当前 multiset 容器中的指定位置直接构造新元素。其效果和 insert() 一样,但效率更高。 |
emplace_hint() | 本质上和 emplace() 在 multiset 容器中构造新元素的方式是一样的,不同之处在于,使用者必须为该方法提供一个指示新元素生成位置的迭代器,并作为该方法的第一个参数。 |
count(val) | 在当前 multiset 容器中,查找值为 val 的元素的个数,并返回。 |
注意,虽然 multiset 容器和 set 容器拥有的成员方法完全相同,但由于 multiset 容器允许存储多个值相同的元素,因此诸如 count()、find()、lower_bound()、upper_bound()、equal_range()等方法,更常用于 multiset 容器。
下面程序演示了表 1 中部分成员函数的用法:
#include
#include
#include
using namespace std;
int main() {
std::multiset mymultiset{1,2,2,2,3,4,5};
cout << "multiset size = " << mymultiset.size() << endl;
cout << “multiset count(2) =” << mymultiset.count(2) << endl;
//向容器中添加元素 8
mymultiset.insert(8);
//删除容器中所有值为 2 的元素
int num = mymultiset.erase(2);
cout << “删除了 " << num << " 个元素 2” << endl;
//输出容器中存储的所有元素
for (auto iter = mymultiset.begin(); iter != mymultiset.end(); ++iter) {
cout << *iter << " ";
}
return 0;
}
程序执行结果为:
multiset size = 7
multiset count(2) =3
删除了 3 个元素 2
1 3 4 5 8
注意,表 1 中大多数成员方法的用法,和 set 容器中相应成员方法的用法是完全一样的,只是调用者不同。因此,如果读者想详细了解表 1 中某个成员方法的用法,可以阅读讲解 set 容器相同成员方法的文章。
前面在讲解如何创建 map、multimap、set 以及 multiset 容器时,遗留了一个问题,即如何自定义关联式容器中的排序规则?
实际上,为关联式容器自定义排序规则的方法,已经在 《STL priority_queue自定义排序方法》一节中做了详细的讲解。换句话说,为 Priority_queue 容器适配器自定义排序规则的方法,同样适用于所有关联式容器。
总的来说,为关联式容器自定义排序规则,有以下 2 种方法。
在掌握此方法之前,读者必须对函数对象有基本的了解,可阅读《C++函数对象》一节。
无论关联式容器中存储的是基础类型(如 int、double、float 等)数据,还是自定义的结构体变量或类对象(包括 string 类),都可以使用函数对象的方式为该容器自定义排序规则。
下面样例以 set 容器为例,演示了如何用函数对象的方式自定义排序规则:
#include
#include // set
#include // string
using namespace std;
//定义函数对象类
class cmp {
public:
//重载 () 运算符
bool operator ()(const string &a,const string &b) {
//按照字符串的长度,做升序排序(即存储的字符串从短到长)
return (a.length() < b.length());
}
};
int main() {
//创建 set 容器,并使用自定义的 cmp 排序规则
std::set<string, cmp>myset{“http://c.biancheng.net/stl/”,
“http://c.biancheng.net/python/”,
“http://c.biancheng.net/java/”};
//输出容器中存储的元素
for (auto iter = myset.begin(); iter != myset.end(); ++iter) {
cout << *iter << endl;
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
需要这份系统化的资料的朋友,可以添加V获取:vip1024b (备注Go)
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
nd()、upper_bound()、equal_range()等方法,更常用于 multiset 容器。
下面程序演示了表 1 中部分成员函数的用法:
#include
#include
#include
using namespace std;
int main() {
std::multiset mymultiset{1,2,2,2,3,4,5};
cout << "multiset size = " << mymultiset.size() << endl;
cout << “multiset count(2) =” << mymultiset.count(2) << endl;
//向容器中添加元素 8
mymultiset.insert(8);
//删除容器中所有值为 2 的元素
int num = mymultiset.erase(2);
cout << “删除了 " << num << " 个元素 2” << endl;
//输出容器中存储的所有元素
for (auto iter = mymultiset.begin(); iter != mymultiset.end(); ++iter) {
cout << *iter << " ";
}
return 0;
}
程序执行结果为:
multiset size = 7
multiset count(2) =3
删除了 3 个元素 2
1 3 4 5 8
注意,表 1 中大多数成员方法的用法,和 set 容器中相应成员方法的用法是完全一样的,只是调用者不同。因此,如果读者想详细了解表 1 中某个成员方法的用法,可以阅读讲解 set 容器相同成员方法的文章。
前面在讲解如何创建 map、multimap、set 以及 multiset 容器时,遗留了一个问题,即如何自定义关联式容器中的排序规则?
实际上,为关联式容器自定义排序规则的方法,已经在 《STL priority_queue自定义排序方法》一节中做了详细的讲解。换句话说,为 Priority_queue 容器适配器自定义排序规则的方法,同样适用于所有关联式容器。
总的来说,为关联式容器自定义排序规则,有以下 2 种方法。
在掌握此方法之前,读者必须对函数对象有基本的了解,可阅读《C++函数对象》一节。
无论关联式容器中存储的是基础类型(如 int、double、float 等)数据,还是自定义的结构体变量或类对象(包括 string 类),都可以使用函数对象的方式为该容器自定义排序规则。
下面样例以 set 容器为例,演示了如何用函数对象的方式自定义排序规则:
#include
#include // set
#include // string
using namespace std;
//定义函数对象类
class cmp {
public:
//重载 () 运算符
bool operator ()(const string &a,const string &b) {
//按照字符串的长度,做升序排序(即存储的字符串从短到长)
return (a.length() < b.length());
}
};
int main() {
//创建 set 容器,并使用自定义的 cmp 排序规则
std::set<string, cmp>myset{“http://c.biancheng.net/stl/”,
“http://c.biancheng.net/python/”,
“http://c.biancheng.net/java/”};
//输出容器中存储的元素
for (auto iter = myset.begin(); iter != myset.end(); ++iter) {
cout << *iter << endl;
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
需要这份系统化的资料的朋友,可以添加V获取:vip1024b (备注Go)
[外链图片转存中…(img-6dFrD3MF-1713433599741)]
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
文章浏览阅读192次。基于javaweb+mysql的jsp+servlet电影票售票管理系统(java+jsp+servlet+javabean+mysql)运行环境Java≥8、MySQL≥5.7、Tomcat≥8开发工具eclipse/idea/myeclipse/sts等均可配置运行适用课程设计,大作业,毕业设计,项目练习,学习演示等功能说明后台:管理用户、影片、排片、影厅、订单、影评等前台:注册登录、查看排片、详情,选座、购票等后台前台技术框架JSP Servlet MySQL C3P0 DBUtil Tomcat J_【java+jsp+mysql】订票系统
文章浏览阅读563次,点赞6次,收藏10次。Flutter中的PageView和TabBarView默认每次切换页面时都会重新构建(build)页面,这样虽然渲染了最新的UI,但是这种行为可能会导致性能问题,特别是页面中有复杂的布局和数据加载时。解决这个问题,可以用AutomaticKeepAliveClientMixin接口和它的wantKeepAlive方法。保持页面状态,避免每次切换都重新构建。_flutter如何防止子view重新build
文章浏览阅读9.7k次,点赞5次,收藏14次。【问题描述】输入一个正整数n(1<n<10),再输入n个整数,存入数组中,再将数组中的数,逆序存放并输出【输入形式】先输入一个整数n,再输入n个整数,用空格间隔【输出形式】输出n个整数,用空格间隔【样例输入】 51 2 3 4 5#include<stdio.h>int main(){ int n,a[10],z,i,j; scanf("%d",&n); for(i=0;i<n;i++) { scanf("%d",&..._c语言多组测试,每组先输入一个不大于10的整数n 然后是n个整数,输出这n个整数中最
文章浏览阅读1.6k次。一、RIL的基本架构Android RIL (Radio Interface Layer)提供了Telephony服务和Radio硬件之间的抽象层。RIL负责数据的可靠传输、AT命令的发送以及response的解析。一般的,应用处理器(AP)通过AT命令集与无线通讯模块(基带/BP)通信。通信的方式又分为主动请求的request(诸如拨号、发短信……),以及Modem主动上报的例如信号_android rild启动
文章浏览阅读560次,点赞22次,收藏21次。uni-app 是一个基于 Vue.js 的跨平台应用开发框架。它允许开发者使用 Vue.js 的语法编写一次代码,然后将该代码发布到多个平台,包括但不限于微信小程序、H5、App 等。uni-app 提供了一套完整的开发工具链和组件库,使开发者能够快速构建跨平台的应用,并具备良好的性能和用户体验。视图容器首先,在components目录下创建一个新的.vue文件,作为自定义组件的文件。例如,可以创建一个名为的文件。在组件文件中,编写组件的模板部分,定义组件的结构和内容。
文章浏览阅读8.1k次,点赞4次,收藏7次。如何生成 .plist文件,plist文件制作教程如何生成 plist文件plist文件制作教程准备好已经切分好的序列图打开软件按图提示操作选择位置保存生成的两个文件 plist png example前期准备软件:TexturePacker要制作的序列图1.准备好已经切分好的序列图2.打开软件3.按图提示操作选择位置保存生成的两个文件 *.plist *.png examp_plist生成
文章浏览阅读831次。本文实例为大家分享了jQuery实现简易QQ聊天框的具体代码,供大家参考,具体内容如下例子1*{list-style: none;margin: 0;padding: 0;}.box1{width: 500px;height: 480px;border: 1px solid #aaa;margin: 0 auto;margin-top: 20px;}.box{width: 500px;height..._pc端类似于qq的html聊天界面
文章浏览阅读1.2w次,点赞9次,收藏13次。在前面的文章中已经多次提到,知识图谱采用图的方式描述和表达知识,相比于简单图,能建模更加复杂的事物关系,但比起形式化逻辑,又免于复杂的逻辑约束,使得知识的获取过程变得更加容易。但在知识图谱的实际实践中,不同的应用场景会对知识的建模采用不同表达能力的图表示方法。例如有些应用场景仅采用最简单的无向图,通常适合于对建模要求不高,偏于数据挖掘类的应用场景。知识图谱表示应用最多的是有向标记图(Directed Labelled Graph)。_知识图谱符号表示
文章浏览阅读710次,点赞8次,收藏17次。这时候软件可能就会识别手机。如果以上方法不可行,又不想花太多时间去找问题,就可以采用安装安装包的方式。我们可以在每一个对应项目对应目录下面的app\build\outputs\apk\debug查找到软件自动生成的安装包。如果是新版的AS的话可能只会看到一个app-debug.apk,并没有什么网上说的app-debug-unaligned.apk什么的两个.apk结尾的文件,这都不要紧,可以把这个拿到手机上直接安装。
文章浏览阅读1w次,点赞11次,收藏38次。unity使用Image实现划线功能_unity quest3 在image上画线
文章浏览阅读3.1k次。今天讲讲获取表单元素的N种方法~以上是部分资料参考的地方:http://blog.csdn.net/h12kjgj/article/details/61624509先给出一个实例。输入数字1~10,弹出输入的数字,并计算该数字的阶乘;如果输入的数字不在该范围内,则输出“balabala自己编的一些话”源代码: function Count(){var i,r,_提取所有表单元素的方法
文章浏览阅读1.8w次,点赞5次,收藏11次。文献导读肠道菌群是指存在于宿主肠道内的微生物集合,它参与了宿主多种重要的生理作用,如影响机体的营养代谢、调节机体免疫系统的发育与成熟及抗菌作用,因此肠道菌群又被人称之为"被遗忘的器官"。随着科学技术的发展,人们逐渐意识到到肠道菌群与全身各个系统的疾病的发生发展都存在着密切的关联,从而提出一些像"肠脑轴"和"肠肝轴"等名词。肠脑轴背景介绍据统计,定植于人体肠道内数量约是人体细胞数量的..._脑肠轴检测指标