目录
函数对象:
概念:重载函数调用操作符的类,其对象经常称为函数对象。函数对象使用重载的()时,行为类似函数调用,也叫仿函数。
本质:函数对象(仿函数)是一个类,不是一个函数。
1.函数对象可以像普通函数那样调用,可以有参数和返回值;
2.函数对象超出普通函数的概念,函数对象可以有自己的状态;
3.函数对象可以作为参数传递;
#include <iostream>
#include<string>
using namespace std;
class Myadd
{
public:
int operator()(int a,int b)
{
return a+b;
}
};
//1.函数对象可以像普通函数那样调用,可以有参数和返回值;
void test01()
{
Myadd myadd1;
int c=myadd1(1,2);
cout<<c<<endl;
}
//2.函数对象超出普通函数的概念,函数对象可以有自己的状态;
class Myprint
{
public:
int count;//记录调用次数
Myprint()
{
this->count=0;
}
void operator()(string str)
{
cout<<str<<endl;
count++;
}
};
void test02()
{
Myprint myprint;
myprint("hello");
myprint("hello");
myprint("hello");
myprint("hello");
cout<<myprint.count<<endl;
}
//3.函数对象可以作为参数传递;
void print03(Myprint &myprint,string s)
{
myprint(s);
}
void test03()
{
Myprint myprint2;
print03(myprint2,"hello c++");
}
int main()
{
test01();
test02();
test03();
return 0;
}
谓词:
概念:
1.返回bool类型的仿函数称为谓词;
2.如果operator()接受一个参数,叫做一元谓词;
3.如果operator()接受两个参数,则为二元谓词。
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class Myfind
{
public:
bool operator()(int val)//一元谓词
{
return val>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(),Myfind());//寻找是否有大于5的数字,如果没有返回end
if(it==v.end())
{
cout<<"No"<<endl;
}
else
{
cout<<*it<<endl;
}
}
class Mycompare
{
public:
bool operator()(int v1,int v2)//二元谓词
{
return v1>v2;
}
};
void test02()
{
vector<int >v;
v.push_back(10);
v.push_back(20);
v.push_back(90);
v.push_back(70);
v.push_back(40);
v.push_back(60);
sort(v.begin(),v.end());
for(vector<int>::iterator it=v.begin();it!=v.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
sort(v.begin(),v.end(),Mycompare());
cout<<"------------------------------------------------"<<endl;
for(vector<int>::iterator it=v.begin();it!=v.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
}
int main()
{
test01();
test02();
return 0;
}
内建函数对象:
1.算术仿函数
template<class T> T minus<T>;//减法
template<class T> T multiplies<T>;//乘法
template<class T> T plus<T>;//加法
template<class T> T divides<T>;//除法
template<class T> T modulus<T>;//取模
template<class T> T negate<T>;//取反
2.关系仿函数
template<class T> bool equal_to<T>;//等于
template<class T> bool not_equal_to<T>;//不等于
template<class T> bool grater<T>;//大于
template<class T> bool grater_equal<T>;//大于等于
template<class T> bool less<T>;//小于
template<class T> bool less_equal<T>;//小于等于
3.逻辑仿函数
template<class T> bool logical_and<T>;//逻辑与
template<class T> bool logical_or<T>;//逻辑或
template<class T> bool logical_not<T>;//逻辑非
#include<functional>
#include <iostream>
#include<algorithm>
#include <vector>
using namespace std;
void test01()
{
negate<int>n;
cout<<n(40)<<endl;
}
void test02()
{
plus<int>p;
cout<<p(10,20)<<endl;
}
void test03()
{
vector<int >v;
v.push_back(10);
v.push_back(20);
v.push_back(90);
v.push_back(70);
v.push_back(40);
v.push_back(60);
sort(v.begin(),v.end(),greater<int>());// 内建关系仿函数调用
for(vector<int>::iterator it=v.begin();it!=v.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
}
void test04()
{
vector<bool>v;
v.push_back(true);
v.push_back(false);
v.push_back(true);
v.push_back(false);
for(vector<bool>::iterator it=v.begin();it!=v.end();it++)
{
cout<<*it<<endl;
}
cout<<endl;
//利用逻辑非 将容器V 搬运到容器v2中,并执行操作
vector<bool>v2;
v2.resize(v.size());
transform(v.begin(),v.end(),v2.begin(),logical_not<bool>());
for(vector<bool>::iterator it=v2.begin();it!=v2.end();it++)
{
cout<<*it<<endl;
}
cout<<endl;
}
int main()
{
test01();
test02();
test03();
test04();
return 0;
}