组合型函数分成以下几种,自己写函数适配器
f(g(elem)) ------> compose_f_gx
f(g(elem1,elem2)) ------> compose_f_gxy
f(g(elem),h(elem)) ------> compose_f_gx_hx
f(g(elem),h(elem2)) ------> compose_f_gx_hy
...
下面是具体的例子,慢慢琢磨:
#include<iostream>
#include<vector>
#include<algorithm>
#include<functional>
#include<iterator>
using namespace std;
template<typename Op1,typename Op2>
class compose_f_gx_t:public unary_function<typename Op2::argument_type,typename Op1::result_type>
{
private:
Op1 op1;
Op2 op2;
public:
compose_f_gx_t(const Op1& o1,const Op2& o2):op1(o1),op2(o2){
}
typename Op1::result_type operator()(const typename Op2::argument_type& x)const {
return op1(op2(x));
}
};
template<typename Op1,typename Op2>
inline compose_f_gx_t<Op1,Op2> compose_f_gx(const Op1& o1,const Op2& o2){
return compose_f_gx_t<Op1,Op2>(o1,o2);
}
int main(){
vector<int>v;
for(int i=1;i<=9;++i){
v.push_back(i);
}
for(vector<int>::iterator itera=v.begin();itera!=v.end();++itera){
cout<<*itera<<" ";
}
cout<<endl;
transform(v.begin(),v.end(),ostream_iterator<int>(cout," "),compose_f_gx(bind2nd(multiplies<int>(),5),bind2nd(plus<int>(),10)));
cout<<endl;
system("pause");
return 0;
}
#include<iostream>
#include<vector>
#include<algorithm>
#include<functional>
using namespace std;
template<typename Op1,typename Op2,typename Op3>
class compose_f_gx_hx_t:public unary_function<typename Op2::argument_type,typename Op1::result_type>
{
private:
Op1 op1;
Op2 op2;
Op3 op3;
public:
compose_f_gx_hx_t(const Op1& o1,const Op2& o2,const Op3& o3):op1(o1),op2(o2),op3(o3){
}
typename Op1::result_type operator()(const typename Op2::argument_type& x)const{
return op1(op2(x),op3(x));
}
};
template<typename Op1,typename Op2,typename Op3>
inline compose_f_gx_hx_t<Op1,Op2,Op3>
compose_f_gx_hx(const Op1& o1,const Op2& o2,const Op3& o3){
return compose_f_gx_hx_t<Op1,Op2,Op3>(o1,o2,o3);
}
int main(){
vector<int>v;
for(int i=1;i<=9;++i){
v.push_back (i);
}
for(vector<int>::iterator itera=v.begin();itera!=v.end();++itera){
cout<<*itera<<" ";
}
cout<<endl;
vector<int>::iterator it;
it=remove_if(v.begin(),v.end(),compose_f_gx_hx(logical_and<bool>(),bind2nd(greater<int>(),4),bind2nd(less<int>(),7)));
v.erase(it,v.end());
for(vector<int>::iterator iterb=v.begin();iterb!=v.end();++iterb){
cout<<*iterb<<" ";
}
cout<<endl;
system("pause");
return 0;
}
#include<iostream>
#include<cctype>
#include<algorithm>
#include<string>
#include<vector>
#include<functional>
using namespace std;
template<typename Op1,typename Op2,typename Op3>
class compose_f_gx_hy_t:public binary_function<typename Op2::argument_type,typename Op3::argument_type,typename Op1::result_type>
{
private:
Op1 op1;
Op2 op2;
Op3 op3;
public:
compose_f_gx_hy_t(const Op1& o1,const Op2& o2,const Op3& o3):op1(o1),op2(o2),op3(o3){
};
typename Op1::result_type operator()(const typename Op2::argument_type& x,const typename Op3::argument_type& y)const{
return op1(op2(x),op3(y));
}
};
template<typename Op1,typename Op2,typename Op3>
inline compose_f_gx_hy_t<Op1,Op2,Op3> compose_f_gx_hy(const Op1& o1,const Op2& o2,const Op3& o3){
return compose_f_gx_hy_t<Op1,Op2,Op3>(o1,o2,o3);
}
int main(){
string s("Internationalization");
string sub("Nation");
string::iterator it;
it=search(s.begin(),s.end(),sub.begin(),sub.end(),compose_f_gx_hy(equal_to<int>(),ptr_fun(::toupper),ptr_fun(::toupper)));
if(it!=s.end()){
cout<<"\""<<sub<<"\" is part of\""<<s<<"\""<<endl;
}
system("pause");
return 0;
}