①简单的比较函数
#include
int countMatchElements(int* beg,int* end)
{
int result = 0;
for(;beg!=end;++beg)
{
if(*beg > 20)
++result;
}
return result;
}
int main()
{
int intArray[]= { 11,16,21,19,17,30 };
//统计大于20的元素数量
std::cout<< countMatchElements(intArray,intArray+6) <<std::endl;
return 0;
}
②加入函数指针的优化(改变:传入不同的函数)
#include
int countMatchElements(int* beg,int* end,bool(*pred)(const int&))
{
int result = 0;
for(;beg!=end;++beg)
{
if(pred(*beg))
++result;
}
return result;
}
//实际比较函数
bool isGreater20(const int &val) {return val > 20};
bool isGreater25(const int &val) {return val > 25};
bool isLess10(const int &val) {return val < 10};
int main()
{
int intArray[]= { 11,16,21,19,17,30 };
//优化后的函数(用了函数指针)
std::cout<< countMatchElements(intArray,intArray+6,isGreater20) <<std::endl;
return 0;
}
③函数模板进一步优化(改变:传入的函数参数为不同类型)
#include
template<typename T>
int countMatchElements(T* beg,T* end,bool(*pred)(const T&))
{
int result = 0;
for(;beg!=end;++beg)
{
if(pred(*beg))
++result;
}
return result;
}
//实际比较函数
bool isGreater20(const int &val) {return val > 20;}
bool isGreater25(const int &val) {return val > 25;}
bool isLess10(const int &val) {return val < 10;}
bool isTinyStr(const stdLLstring &val) {return val.size() <=3;}
int main()
{
int intArray[]= { 11,16,21,19,17,30 };
//优化后的函数(用了函数指针)
std::cout<< countMatchElements(intArray,intArray+6,isGreater20) <<std::endl;
return 0;
}
④用仿函数进一步优化(改变:传入的函数参数为不同值,之前无论是模板还是函数指针都是写死的)
#include
template<typename T,typename Pred>
int countMatchElements(T* beg,T* end,Pred pred)
{
int result = 0;
for(;beg!=end;++beg)
{
if(pred(*beg))
++result;
}
return result;
}
//仿函数
template<typename T>
struct Greater{
T mVal;//
//explicit只能用于修饰只有一个参数的类构造函数, 它的作用是表明该构造函数是显示
explicit Greater(T value):mVal(value) {} //构造函数初始化mVal
bool operator() (const T& val) const { return val > mVal;}//重载函数调用运算符
};
int main()
{
int intArray[]= { 11,16,21,19,17,30 };
//阈值设置为20
Greater<int> greater20{20};//不过仿函数无法给函数指针赋值
//优化后的函数(用了函数指针)
std::cout<< countMatchElements(intArray,intArray+6,greater20) <<std::endl;
return 0;
}
⑤仿函数代码难以阅读,可以用lambda表达式改造下
#include
template<typename T,typename Pred>
int countMatchElements(T* beg,T* end,Pred pred)
{
int result = 0;
for(;beg!=end;++beg)
{
if(pred(*beg))
++result;
}
return result;
}
//仿函数
template<typename T>
struct Greater{
T mVal;//
//explicit只能用于修饰只有一个参数的类构造函数, 它的作用是表明该构造函数是显示
explicit Greater(T value):mVal(value) {} //构造函数初始化mVal
bool operator() (const T& val) const { return val > mVal;}//重载函数调用运算符
};
int main()
{
int intArray[]= { 11,16,21,19,17,30 };
//阈值设置为20
//Greater greater20{20};//不过仿函数无法给函数指针赋值
auto greater20 = [](auto &val)->bool {return val>20;};
//优化后的函数(用了函数指针)
std::cout<< countMatchElements(intArray,intArray+6,greater20) <<std::endl;
return 0;
}