c++学习总结

一.泛型算法总结

// 1.find查找算法（只读）
auto ret_it = find(vec1.begin(),vec1.ebd(),3);  //返回的是指向该元素的迭代器，没有找到则指向vec1.end()
auto ret_it = find_if(vec1.begin(),vec1.ebd(),[](int val){return val>3;});  //返回的是第一个大于3的元素的迭代器，没有找到则指向vec1.end()
//2.accumulate求和算法（只读），需包含头文件#include<numeric>
auto sum = accumulate(vec1.begin(),vec1.end(),0);//返回的是vec1容器中的元素和，起始为0
//3.equal确定两个序列中保存的值是否相等
bool ret = equal(vec1.begin(),vec1.end(),vec2.begin());  //比较vec1从头到尾是否和vec2相等，这里vec2的长度一定要大于vec1，否则会报错
//4.back_inserter和front_inserter在容器首尾插入元素，返回的是指向该元素的迭代器
	//以下3条语句效果相等
back_inserter(vec1) = 1;  
*back_inserter(vec1) = 1;  
vec1.pushback(1);
	//对于list容器还有front_inserter操作
*front_inserter(lst1) = 1;  
//5.fill函数将容器中的元素全部置为固定值
fill(vec1.begin(),vec1.begin()+3,123);  //将begin到begin+3位置填充上三
fill_n(vec1.begin(),3,123);  //给容器vec1从begin开始填入3个123
//6.copy算法
vector<int>vec2;
vec2.resize(100);   //首先保证vec2的空间够用
copy(vec1.begin(),vec1.end(),vec2.begin());  //将vec1的全部元素copy到vec2中
	//另外，采用和back_inserter相结合的方式可以不用提前给vec2 resize
copy(vec1.begin(),vec1.end(),back_inserter(vec2));  //将vec1的全部元素copy到vec2中,因为back_inserter返回的是指向vec2尾元素的迭代器且会不断增长
	//copy_if含条件判断copy
vector<int>target;
copy_if(vec1.begin(),vec1.end(),back_inserter(target),[](int val){return val>2;});
//7.repalce替代函数
replace(vec1.begin(),vec1.end(),1,11); //从begin到end扫描vec1，将1替换成11
replace_if(vec.begin(), vec.end(), bind2nd(myreplace(),val),888);   //将大于val的值替换为888
//8.重排容器元素的算法:unique
sort(vec1.begin(),vec1.end());//首先将容器元素重新升序排列
auto ret_it = unique(vec1.begin(),vec1.end()); //对vec1容器进行去重处理,重复元素都会被放到后面，返回值就是指向开始重复元素的迭代器
vec1.erase(ret_it,vec1.end());
	//另外，考虑到set关联容器天生就有去重作用，可以使用set容器实现去重
set<int>set1(vec1.begin(),vec.end());   //set1中的元素自动完成升序和去重
	//另外，如果考虑改变set元素默认的升序排列尾降序排列，可以使用仿函数实现，在构建set容器时完成对()的重载。
	class mycmp
	{
	public:
		bool operator()(int val1, int val2)const
		{
			return val1 > val2;
		}
	};
	set<int,mycmp>set1;   //构建出的set1容器默认降序排列
//9.sort排序
sort(vec1.begin(),vec1.end());  //默认进行升序排列
sort(vec1.begin(),vec1.end()，isgreater<int>());  //使用内建函数实现降序排列，另外还可以使用谓词、lambda表达式、伪函数实现同样的效果
//10.swap交换函数
swap(vec1, vec2);  //vec1和vec2中的元素完全交换
//11.reverse函数
reverse(vec1.begin(),vec1.end());     //完全反转vec1中的元素
reverse_copy(vec.begin(), vec.end(), back_inserter(vec_copy));   //reverse_copy(begin,end,dest),将容器元素反转后拷贝到目的地址
//12.remove函数
vector<int> vec1 = { 1,2,3,4,5,6,7 };
auto ret_it = remove(vec1.begin(), vec1.end(),5);   //remove之后元素个数并不会少，返回的是remove之后末尾元素的迭代器
vec1.erase(ret_it, vec1.end());//删除后面被remonve的元素
	//remove_if函数的使用
auto remove_it = remove_if(vec1.begin(), vec1.end(), [](int val){return val > 4; });
vec1.erase(remove_it, vec1.end());      //删除后面被remonve的元素
/***********************一些排序算法***************************/
//13.merge排序的使用：将两个容器合并并存放到第三个容器中，但合并的两个容器必须为有序容器，且排序规则相同（只能为升序）
vector<int>vec1 = { 1,3,5,7,9};
vector<int>vec2 = { 2,4,6,8,10,0};
sort(vec1.begin(), vec1.end()); //先将两个容器进行升序排列
sort(vec2.begin(), vec2.end()); //先将两个容器进行升序排列
vector<int>target;  //定义目标容器
target.resize(vec1.size()+vec2.size());     //先给目标容器分配足够的空间
merge(vec1.begin(), vec1.end(),vec2.begin(), vec2.end(),taget.begin());   //将vec1和vec2中的元素全部merger到target中，自动完成按照升序排列
for_each(target.begin(), target.end(), [](int val) {cout << val << " "; });
	//输出的结果是：0 1 1 2 3 4 5 6 7 8 9 10    可以看出，自动按照升序融合了
//11.random_shuffle随机洗牌算法，也就是打乱算法
random_shuffle(vec1.begin(),vec1.end());
/***********************求两个集合的交、并、差集***************************/
//1.求交，对于求交的两个集合一定要是有序集合，且排序规则一致
vector<int> vec1 = { 1,3,3,12,13,12,4,5,6,7,8,9 };
sort(vec1.begin(), vec1.end());
vector<int> vec2 = { 1,3,3,4,456,123};
sort(vec2.begin(), vec2.end());
vector<int> target;  //定义目标集合
target.resize(min(vec1.size(), vec2.size()));     //给目标容器分配大小为两个容器中较小的那个（因为是求并）
auto end_it = set_intersection(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), target.begin());  //求vec1和vec2两个容器的交集部分，结果放在target容器中，返回的是target容器并集结束部分
for_each(target.begin(), end_it, [](int val) {cout << val << " "; });//输出 1 3 3 4
for_each(target.begin(), target.end(), [](int val) {cout << val << " "; });//输出 1 3 3 4 0 0
//2.求并，对于求并的两个集合一定要是有序集合，且排序规则一致
vector<int> vec1 = { 1,3,3,12,13,12,4,5,6,7,8,9 };
sort(vec1.begin(), vec1.end());
vector<int> vec2 = { 1,3,3,4,456,123};
sort(vec2.begin(), vec2.end());
vector<int> target;  //定义目标集合
target.resize(vec1.size()+vec2.size(),0);     //给目标容器分配大小为两个容器大小之和
auto end_it = set_union(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), target.begin());  //求vec1和vec2两个容器的并集部分，结果放在target容器中，返回的是并集部分的尾元素之后的迭代器
for_each(target.begin(), end_it, [](int val) {cout << val << " "; });//输出 1 3 3 4 5 6 7 8 9 12 12 13 123 456
for_each(target.begin(), target.end(), [](int val) {cout << val << " "; });//输出 1 3 3 4 5 6 7 8 9 12 12 13 123 456 0 0 0 0
//3.求差：set_difference，对于求差的两个集合一定要是有序集合，且排序规则一致，求差分两种情况：A-B或B-A
vector<int> vec1 = { 1,3,3,12,13,12,4,5,6,7,8,9 };
sort(vec1.begin(), vec1.end());
vector<int> vec2 = { 1,3,3,4,456,123};
sort(vec2.begin(), vec2.end());
vector<int> target;  //定义目标集合
target.resize(max(vec1.size(),vec2.size()),0);     //给目标容器分配大小为两个容器之中较大的哪个
auto end_it = set_difference(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), target.begin());  //求vec1-vec2两个容器的差集部分，结果放在target容器中
for_each(target.begin(), end_it, [](int val) {cout << val << " "; });//输出：5 6 7 8 9 12 12 13
end_it = set_difference(vec2.begin(), vec2.end(), vec1.begin(), vec1.end(), target.begin());  //求vec2-vec1两个容器的差集部分，结果放在target容器中
for_each(target.begin(), end_it, [](int val) {cout << val << " "; });//输出：123 456

二.各容器成员函数总结

一.list容器(区别于vector容器的额外成员函数)
//1.merge函数(合并的两个list容器必须是有序的，且排序方法一致)
lst1.merge(lst2); //自动将lst2合并到lst1容器中
	//还可以使用泛型算法merge实现同样的效果
	merge(lst1.begin(), lst1.end(), lst2.begin(), lst2.end(), lst3.begin());
//2.reverse成员函数
lst1.reverse(); //自动完成list容器中元素的反转
//3.sort排序
lst1.sort(); //自动完成list容器中元素的升序排列
//4.unique自动完成相邻重复元素的删除
lst1.unique(); //自动完成list容器中相邻重复元素的删除，二对于非相邻元素不能删除，因此需要使用sort先排序，后使用unique删除相邻重复元素
//5.remove删除容器中的元素
lst1.remove(5); //删除list容器中的所有5元素

三.容器的使用

//1.set容器的使用
set<int> set1 = { 2,1,3,4,5 };  //只保留key值,会自动去重和排序（升序）
set1.insert(4);					//不能出现重复值,set会自动去重
cout << "set1.size()= "<<set1.size() << endl;
for_each(set1.begin(), set1.end(), [](int val) {cout << val << " "; });  //输出 1 2 3 4 5
//2.pair对的使用
vector<int> vec1 = { 1,2,3,4,5,6 };
pair<string, vector<int>> pair1 = {"kkkk",vec1};  //列表初始化建立pair对
pair1.second.push_back(99);
pair<string, string> pair2;
pair2 = make_pair("aaaaaa", "bbbbbb");          //使用make_pair函数建立pair对
//3.map<key,value>容器的使用，会按照key值进行去重和排序
map<int, string> map1 = { {1,"aaaa"},{2,"bbbbb"} };  //初始化的时候添加元素
map1.insert(make_pair(3, "ccccc"));  //使用insert添加
map1.insert(pair<int, string>(4, "dddd"));
map1[5] = "eeee";   //使用key值添加元素
//4.unordered_map无须容器，不会按照key值自动排列，会按照插进入容器时的
map<int, string, mycompare> map1;
map1[2] = "bbbb";
map1[4] = "dddd";
map1[3] = "cccc";
map1[1] = "aaaa";
print_map(map1);                 //不自动进行排序，按照插入时的顺序实现排序