【STL】常用算法
2017-10-13 23:52
681 查看
常用算法
函数对象
重载函数调用操作符的类,其对象常称为函数对象(function object),即它们是行为类似函数的对象,也叫仿函数(functor),其实就是重载“()”操作符,使得类对象可以像函数那样调用。注意:
1.函数对象(仿函数)是一个类,不是一个函数。
2.函数对象(仿函数)重载了”() ”操作符使得它可以像函数一样调用。
分类:假定某个类有一个重载的operator(),而且重载的operator()要求获取一个参数,我们就将这个类称为“一元仿函数”(unary functor);相反,如果重载的operator()要求获取两个参数,就将这个类称为“二元仿函数”(binary
functor)。
函数对象的作用主要是什么?STL提供的算法往往都有两个版本,其中一个版本表现出最常用的某种运算,另一版本则允许用户通过template参数的形式来指定所要采取的策略。
//函数对象是重载了函数调用符号的类 class MyPrint { public: MyPrint() { m_Num = 0; } int m_Num; public: void operator() (int num) { cout << num << endl; m_Num++; } }; //函数对象 //重载了()操作符的类实例化的对象,可以像普通函数那样调用,可以有参数 ,可以有返回值 void test01() { MyPrint myPrint; myPrint(20); } // 函数对象超出了普通函数的概念,可以保存函数的调用状态 void test02() { MyPrint myPrint; myPrint(20); myPrint(20); myPrint(20); cout << myPrint.m_Num << endl; } void doBusiness(MyPrint print,int num) { print(num); } //函数对象作为参数 void test03() { //参数1:匿名函数对象 doBusiness(MyPrint(),30); } |
1、函数对象通常不定义构造函数和析构函数,所以在构造和析构时不会发生任何问题,避免了函数调用的运行时问题。
2、函数对象超出普通函数的概念,函数对象可以有自己的状态
3、函数对象可内联编译,性能好。用函数指针几乎不可能
4、模版函数对象使函数对象具有通用性,这也是它的优势之一
谓词
谓词是指普通函数或重载的operator()返回值是bool类型的函数对象(仿函数)。如果operator接受一个参数,那么叫做一元谓词,如果接受两个参数,那么叫做二元谓词,谓词可作为一个判断式。class GreaterThenFive { public: bool operator()(int num) { return num > 5; } }; //一元谓词 void test01() { vector<int>v; for (int i = 0;i < 10;i ++) { v.push_back(i); } vector<int>::iterator it = find_if(v.begin(),v.end(),GreaterThenFive()); if (it ==v.end()) { cout << "没有找到" <<endl; } else { cout << "找到了: " << *it <<endl; } } //二元谓词 class MyCompare { public: bool operator()(int num1,int num2) { return num1 >num2; } }; void test02() { vector<int>v; v.push_back(10); v.push_back(40); v.push_back(20); v.push_back(90); v.push_back(60); //默认从小到大 sort(v.begin(),v.end()); for (vector<int>::iterator it =v.begin();it != v.end();it++) { cout << *it <<" "; } cout << endl; cout << "----------------------------" << endl; //使用函数对象改变算法策略,排序从大到小 sort(v.begin(),v.end(),MyCompare()); for (vector<int>::iterator it =v.begin();it != v.end();it++) { cout << *it <<" "; } cout << endl; } |
内建函数对象
STL内建了一些函数对象。分为:算数类函数对象,关系运算类函数对象,逻辑运算类仿函数。这些仿函数所产生的对象,用法和一般函数完全相同,当然我们还可以产生无名的临时对象来履行函数功能。使用内建函数对象,需要引入头文件#include<functional>。n 6个算数类函数对象,除了negate是一元运算,其他都是二元运算。
template<class T>T plus<T>//加法仿函数 template<class T> T minus<T>//减法仿函数 template<class T> T multiplies<T>//乘法仿函数 template<class T> T divides<T>//除法仿函数 template<class T> T modulus<T>//取模仿函数 template<class T> T negate<T>//取反仿函数 |
n 6个关系运算类函数对象,每一种都是二元运算。
template<class T>bool equal_to<T>//等于 template<class T>bool not_equal_to<T>//不等于 template<class T>bool greater<T>//大于 template<class T>bool greater_equal<T>//大于等于 template<class T>bool less<T>//小于 template<class T>bool less_equal<T>//小于等于 |
n 逻辑运算类运算函数,not为一元运算,其余为二元运算。
template<class T>bool logical_and<T>//逻辑与 template<class T>bool logical_or<T>//逻辑或 template<class T>bool logical_not<T>//逻辑非 |
内建函数对象举例:
//取反仿函数 void test01() { negate<int>n; cout << n(50) << endl; } //加法仿函数 void test02() { plus<int>p; cout << p(10, 20) << endl; } //大于仿函数 void test03() { vector<int>v; srand((unsigned int)time(NULL)); for (int i = 0;i < 10; i++){ v.push_back(rand() % 100); } for (vector<int>::iterator it =v.begin();it != v.end();it++){ cout << *it <<" "; } cout << endl; sort(v.begin(),v.end(),greater<int>()); for (vector<int>::iterator it =v.begin();it != v.end();it++){ cout << *it <<" "; } cout << endl; } |
函数对象适配器
//函数适配器bind1st bind2nd //现在我有这个需求 在遍历容器的时候,我希望将容器中的值全部加上100之后显示出来,怎么做? //我们直接给函数对象绑定参数 编译阶段就会报错 //for_each(v.begin(), v.end(), bind2nd(myprint(),100)); //如果我们想使用绑定适配器,需要我们自己的函数对象继承binary_function 或者 unary_function //根据我们函数对象是一元函数对象 还是二元函数对象 class MyPrint :public binary_function<int,int,void> { public: void operator()(int v1,int v2)const { cout << "v1 = : " << v1 << " v2 = :" <<v2 << " v1+v2 = :" << (v1 + v2) << endl; } }; //1、函数适配器 void test01() { vector<int>v; for (int i = 0;i < 10; i++) { v.push_back(i); } cout << "请输入起始值:" << endl; int x; cin >> x; for_each(v.begin(),v.end(),bind1st(MyPrint(),x)); //for_each(v.begin(), v.end(), bind2nd( MyPrint(),x )); } //总结: bind1st和bind2nd区别? //bind1st : 将参数绑定为函数对象的第一个参数 //bind2nd : 将参数绑定为函数对象的第二个参数 //bind1st bind2nd将二元函数对象转为一元函数对象 class GreaterThenFive:public unary_function<int,bool> { public: bool operator ()(int v)const { return v > 5; } }; //2、取反适配器 void test02() { vector <int>v; for (int i = 0;i < 10;i++) { v.push_back(i); } // vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterThenFive()); //返回第一个大于5的迭代器 //vector<int>::iterator it = find_if(v.begin(), v.end(), not1(GreaterThenFive())); //返回第一个小于5迭代器 //自定义输入 vector<int>::iterator it =find_if(v.begin(),v.end(),not1 ( bind2nd(greater<int>(),5))); if (it ==v.end()) { cout << "没找到" << endl; } else { cout << "找到" << *it << endl; } //排序 二元函数对象 sort(v.begin(),v.end(),not2(less<int>())); for_each(v.begin(),v.end(), [](int val){cout <<val << " "; }); } //not1 对一元函数对象取反 //not2 对二元函数对象取反 void MyPrint03(int v,int v2) { cout << v + v2<< " "; } //3、函数指针适配器 ptr_fun void test03() { vector <int>v; for (int i = 0;i < 10; i++) { v.push_back(i); } // ptr_fun( )把一个普通的函数指针适配成函数对象 for_each(v.begin(),v.end(),bind2nd( ptr_fun(MyPrint03 ), 100)); } //4、成员函数适配器 class Person { public: Person(string name,int age) { m_Name = name; m_Age = age; } //打印函数 void ShowPerson(){ cout << "成员函数:" << "Name:" << m_Name << " Age:" << m_Age << endl; } void Plus100() { m_Age += 100; } public: string m_Name; int m_Age; }; void MyPrint04(Person &p) { cout << "姓名:" << p.m_Name <<" 年龄:" << p.m_Age << endl; }; void test04() { vector <Person>v; Person p1("aaa", 10); Person p2("bbb", 20); Person p3("ccc", 30); Person p4("ddd", 40); v.push_back(p1); v.push_back(p2); v.push_back(p3); v.push_back(p4); //for_each(v.begin(), v.end(), MyPrint04); //利用 mem_fun_ref 将Person内部成员函数适配 for_each(v.begin(),v.end(),mem_fun_ref(&Person::ShowPerson)); // for_each(v.begin(), v.end(), mem_fun_ref(&Person::Plus100)); // for_each(v.begin(), v.end(), mem_fun_ref(&Person::ShowPerson)); } void test05(){ vector<Person*>v1; //创建数据 Person p1("aaa", 10); Person p2("bbb", 20); Person p3("ccc", 30); Person p4("ddd", 40); v1.push_back(&p1); v1.push_back(&p2); v1.push_back(&p3); v1.push_back(&p4); for_each(v1.begin(),v1.end(),mem_fun(&Person::ShowPerson)); } //如果容器存放的是对象指针, 那么用mem_fun //如果容器中存放的是对象实体,那么用mem_fun_ref |
算法概述
算法主要是由头文件<algorithm> <functional> <numeric>组成。
<algorithm>是所有STL头文件中最大的一个,其中常用的功能涉及到比较,交换,查找,遍历,复制,修改,反转,排序,合并等...
<numeric>体积很小,只包括在几个序列容器上进行的简单运算的模板函数.
<functional> 定义了一些模板类,用以声明函数对象。
常用遍历算法
/* 遍历算法 遍历容器元素 @param beg 开始迭代器 @param end 结束迭代器 @param _callback 函数回调或者函数对象 @return 函数对象 */ for_each(iterator beg, iterator end, _callback); /* transform算法 将指定容器区间元素搬运到另一容器中 注意 : transform 不会给目标容器分配内存,所以需要我们提前分配好内存 @param beg1 源容器开始迭代器 @param end1 源容器结束迭代器 @param beg2 目标容器开始迭代器 @param _cakkback 回调函数或者函数对象 @return 返回目标容器迭代器 */ transform(iterator beg1, iterator end1, iterator beg2, _callbakc) |
for_each:
/* template<class _InIt,class _Fn1> inline void for_each(_InIt _First, _InIt _Last, _Fn1 _Func) { for (; _First != _Last; ++_First) _Func(*_First); } */ //普通函数 void print01(int val){ cout << val << " "; } //函数对象 struct print001{ void operator()(int val){ cout << val << " "; } }; //for_each算法基本用法 void test01(){ vector<int> v; for (int i= 0; i< 10;i++){ v.push_back(i); } //遍历算法 for_each(v.begin(), v.end(), print01); cout << endl; for_each(v.begin(), v.end(), print001()); cout << endl; } struct print02{ print02(){ mCount = 0; } void operator()(int val){ cout << val << " "; mCount++; } int mCount; }; //for_each返回值 void test02(){ vector<int> v; for (int i= 0; i< 10; i++){ v.push_back(i); } print02 p = for_each(v.begin(), v.end(), print02()); cout << endl; cout << p.mCount<< endl; } struct print03 : public binary_function<int, int, void>{ void operator()(int val,int bindParam) const{ cout << val + bindParam<< " "; } }; //for_each绑定参数输出 void test03(){ vector<int> v; for (int i= 0; i< 10; i++){ v.push_back(i); } for_each(v.begin(), v.end(), bind2nd(print03(),100)); } |
transform:
//transform 将一个容器中的值搬运到另一个容器中 /* template<class _InIt, class _OutIt, class _Fn1> inline _OutIt _Transform(_InIt _First, _InIt _Last,_OutIt _Dest, _Fn1 _Func) { for (; _First != _Last; ++_First, ++_Dest) *_Dest = _Func(*_First); return (_Dest); } template<class _InIt1,class _InIt2,class _OutIt,class _Fn2> inline _OutIt _Transform(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _OutIt _Dest, _Fn2 _Func) { for (; _First1 != _Last1; ++_First1, ++_First2, ++_Dest) *_Dest = _Func(*_First1, *_First2); return (_Dest); } */ struct transformTest01{ int operator()(int val){ return val + 100; } }; struct print01{ void operator()(int val){ cout << val << " "; } }; void test01(){ vector<int> vSource; for (int i= 0; i< 10;i++){ vSource.push_back(i+ 1); } //目标容器 vector<int> vTarget; //给vTarget开辟空间 vTarget.resize(vSource.size()); //将vSource中的元素搬运到vTarget vector<int>::iterator it= transform(vSource.begin(), vSource.end(), vTarget.begin(), transformTest01()); //打印 for_each(vTarget.begin(), vTarget.end(), print01()); cout<< endl; } //将容器1和容器2中的元素相加放入到第三个容器中 struct transformTest02{ int operator()(int v1,int v2){ return v1 + v2; } }; void test02(){ vector<int> vSource1; vector<int> vSource2; for (int i= 0; i< 10; i++){ vSource1.push_back(i+ 1); } //目标容器 vector<int> vTarget; //给vTarget开辟空间 vTarget.resize(vSource1.size()); transform(vSource1.begin(), vSource1.end(), vSource2.begin(),vTarget.begin(), transformTest02()); //打印 for_each(vTarget.begin(), vTarget.end(), print01()); cout<< endl; } |
常用查找算法
/* find算法 查找元素 @param beg 容器开始迭代器 @param end 容器结束迭代器 @param value 查找的元素 @return 返回查找元素的位置 */ find(iterator beg, iterator end, value) /* find_if算法 条件查找 @param beg 容器开始迭代器 @param end 容器结束迭代器 @param callback 回调函数或者谓词(返回bool类型的函数对象) @return bool 查找返回true 否则false */ find_if(iterator beg, iterator end, _callback); /* adjacent_find算法 查找相邻重复元素 @param beg 容器开始迭代器 @param end 容器结束迭代器 @param _callback 回调函数或者谓词(返回bool类型的函数对象) @return 返回相邻元素的第一个位置的迭代器 */ adjacent_find(iterator beg, iterator end, _callback); /* binary_search算法 二分查找法 注意: 在无序序列中不可用 @param beg 容器开始迭代器 @param end 容器结束迭代器 @param value 查找的元素 @return bool 查找返回true 否则false */ bool binary_search(iterator beg, iterator end, value); /* count算法 统计元素出现次数 @param beg 容器开始迭代器 @param end 容器结束迭代器 @param value回调函数或者谓词(返回bool类型的函数对象) @return int返回元素个数 */ count(iterator beg, iterator end, value); /* count_if算法 统计元素出现次数 @param beg 容器开始迭代器 @param end 容器结束迭代器 @param callback 回调函数或者谓词(返回bool类型的函数对象) @return int返回元素个数 */ count_if(iterator beg, iterator end, _callback); |
常用排序算法
/* (初始必须为有序)merge算法 容器元素合并,并存储到另一容器中 @param beg1 容器1开始迭代器 @param end1 容器1结束迭代器 @param beg2 容器2开始迭代器 @param end2 容器2结束迭代器 @param dest 目标容器开始迭代器 */ merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest) /* sort算法 容器元素排序 注意:两个容器必须是有序的 @param beg 容器1开始迭代器 @param end 容器1结束迭代器 @param _callback 回调函数或者谓词(返回bool类型的函数对象) */ sort(iterator beg, iterator end, _callback) /* random_shuffle算法 对指定范围内的元素随机调整次序 @param beg 容器开始迭代器 @param end 容器结束迭代器 */ random_shuffle(iterator beg, iterator end) /* reverse算法 反转指定范围的元素 @param beg 容器开始迭代器 @param end 容器结束迭代器 */ reverse(iterator beg, iterator end) |
常用拷贝和替换算法
/* copy算法 将容器内指定范围的元素拷贝到另一容器中 @param beg 容器开始迭代器 @param end 容器结束迭代器 @param dest 目标起始迭代器 */ copy(iterator beg, iterator end, iterator dest) /* replace算法 将容器内指定范围的旧元素修改为新元素 @param beg 容器开始迭代器 @param end 容器结束迭代器 @param oldvalue 旧元素 @param oldvalue 新元素 */ replace(iterator beg, iterator end, oldvalue, newvalue) /* replace_if算法 将容器内指定范围满足条件的元素替换为新元素 @param beg 容器开始迭代器 @param end 容器结束迭代器 @param callback函数回调或者谓词(返回Bool类型的函数对象) @param oldvalue 新元素 */ replace_if(iterator beg, iterator end, _callback, newvalue) /* swap算法 互换两个容器的元素 @param c1容器1 @param c2容器2 */ swap(container c1, container c2) |
常用算数生成算法
/* accumulate算法 计算容器元素累计总和 @param beg 容器开始迭代器 @param end 容器结束迭代器 @param value累加值 */ accumulate(iterator beg, iterator end, value) /* fill算法 向容器中添加元素 @param beg 容器开始迭代器 @param end 容器结束迭代器 @param value t填充元素 */ fill(iterator beg, iterator end, value) |
常用集合算法
/* set_intersection算法 求两个set集合的交集 注意:两个集合必须是有序序列 @param beg1 容器1开始迭代器 @param end1 容器1结束迭代器 @param beg2 容器2开始迭代器 @param end2 容器2结束迭代器 @param dest 目标容器开始迭代器 @return 目标容器的最后一个元素的迭代器地址 */ set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest) /* set_union算法 求两个set集合的并集 注意:两个集合必须是有序序列 @param beg1 容器1开始迭代器 @param end1 容器1结束迭代器 @param beg2 容器2开始迭代器 @param end2 容器2结束迭代器 @param dest 目标容器开始迭代器 @return 目标容器的最后一个元素的迭代器地址 */ set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest) /* set_difference算法 求两个set集合的差集 注意:两个集合必须是有序序列 @param beg1 容器1开始迭代器 @param end1 容器1结束迭代器 @param beg2 容器2开始迭代器 @param end2 容器2结束迭代器 @param dest 目标容器开始迭代器 @return 目标容器的最后一个元素的迭代器地址 */ set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest) |
相关文章推荐
- STL常用算法4----mem_fun
- 浅析STL中的常用算法
- STL常用算法
- C++:STL常用函数模块总结(算法algorithm)
- STL常用的拷贝替换算术集合算法
- STL中的常用算法
- STL一些常用的容器和算法--总结
- STL常用算法
- STL中的常用算法
- STL 常用算法
- STL学习之十四:常用算法 for_each 和 transform以及adjacent_find的示例代码
- STL常用容器和算法1
- stl常用算法_排序相关
- STL中比较常用的容器是vector,set和map,比较常用的算法有Sort等。
- 常用STL容器及算法举例
- 常用STL容器及算法举例
- 常用STL算法3_排序
- 【STL】<algorithm><numeric><functional> 中的常用算法
- 【算法专题】工欲善其事必先利其器—— 常用函数和STL
- 【算法专题】工欲善其事必先利其器—— C++ STL中vector(向量/不定长数组)的常用方法总结