前提：
本博客对比 函数指针实现回调 和 仿函数 ，突出仿函数的优势。
目的：
一个类要能够灵活的调用两个函数，essfc 和 greaterfc，分别用于比较两个整数的大小：
①：lessfc：判断 x 是否小于 y，如果是则返回 true，否则返回 false。
②：greaterfc：判断 x 是否大于 y，如果是则返回 true，否则返回 false
一：函数指针实现回调
①：普通代码：
cpp
//lessfc函数 x<y？
bool lessfc(int x, int y)
{
return x < y;
}
//greaterfc函数 x>y?
bool greaterfc(int x, int y)
{
return x > y;
}
// A这个类体现了--->函数指针实现回调
class A
{
public:
A(bool(*pf)(int, int))//构造函数接收一个函数指针 并赋值给成员变量
:_pf(pf)
{}
void func(int xx, int yy)//func函数接收两个参数
{
cout << "void func(int xx, int yy)" << _pf(xx, yy) << endl;;
} //用接收到的函数指针结合两个int参数调用该函数
bool(*_pf)(int, int);//成员变量也是一个函数指针类型
};
int main()
{
A aa1(lessfc);//创建一个对象
aa1.func(1, 2);//调用对象的func函数 且传两个int
A aa2(greaterfc);//创建一个对象
aa2.func(1, 2);//调用对象的func函数 且传两个int
}运行结果：
解释：
类 A 的行为可以通过传入不同的函数指针来动态改变：
传入 lessfc 时，func 方法会执行小于比较。
传入 greaterfc 时，func 方法会执行大于比较。
②：加上模版的代码：
cpp
//lessfc函数 x<y？
template<class T>
bool lessfc(T x, T y)
{
return x < y;
}
//greaterfc函数 x>y?
template<class T>
bool greaterfc(T x, T y)
{
return x > y;
}
// A这个类体现了--->函数指针实现回调
template<class T>
class A
{
public:
A(bool(*pf)(T, T))//构造函数接收一个函数指针 并赋值给成员变量
:_pf(pf)
{}
void func(T xx, T yy)//func函数接收两个参数
{
cout << "void func(T xx, T yy)" << _pf(xx, yy) << endl;;
} //用接收到的函数指针结合两个int参数调用该函数
bool(*_pf)(T, T);//成员变量也是一个函数指针类型
};
int main()
{
A<int> aa1(lessfc);//因为有模版，所以显式传模版的类型去创建一个对象
aa1.func(1, 2);//调用对象的func函数 且传两个int 与创建时T的类型吻合
A<double>aa2(greaterfc);//因为有模版，所以显式传模版的类型创建一个对象
aa2.func(1.1, 1.0);//调用对象的func函数 且传两个double 与创建时T的类型吻合
}
**解释：**加上模版之后，范围更广了
二：仿函数
++**定义：**一个对象能像函数一样用，实际上调用的是我们重载的 operator()++
①：普通代码：
cpp
//定义仿函数
class lessfc //将之前的lessfc函数封装成一个类
{
public:
//类中仅需对()这个操作符进行重载
bool operator()(const int& x, const int& y)
{
return x < y;
}
};
//定义仿函数
class greaterfc //将greaterfc函数封装成一个类
{
public:
//类中仅需对()这个操作符进行重载
bool operator()(const int& x, const int& y)
{
return x > y;
}
};
template<class Comapre>
class A//A这个类要使用仿函数
{
public:
void func(int xx, int yy)
{
Comapre com;//创建一个 Comapre 类型的对象 com。
cout << "void func(int xx, int yy)" << com(xx, yy) << endl;;
//调用 com(xx, yy)，即调用仿函数的 operator()，比较 xx 和 yy。
}
};
int main()
{
A<less<int>> aa1;
aa1.func(1, 2); // 输出 1 < 2 的结果（true）
A<greater<int>> aa2;
aa2.func(1, 2); // 输出 1 > 2 的结果（false）
}运行结果：
①：不再像函数指针那样，赤裸裸的写两个函数，而是在两个类中对()运算符进行重载，重载的定义在写函数的功能
②：需要用仿函数的类的模版参数，就是那两个仿函数的类名，在类中进行仿函数类的对象的创建，再结合类中函数(如func)的参数，最后结合()进行函数的调用，仿函数对象看见()就会实现重载后的功能
③：main函数中的less<int>，就是对仿函数进行显式的调用，此时的模版不再是简单的类型，而是一个类
②：加上模版的代码：
cpp
//定义仿函数
template<class T>
class lessfc //将之前的lessfc函数封装成一个类
{
public:
//类中仅需对()这个操作符进行重载
bool operator()(const T& x, const T& y)
{
return x < y;
}
};
//定义仿函数
template<class T>
class greaterfc //将greaterfc函数封装成一个类
{
public:
//类中仅需对()这个操作符进行重载
bool operator()(const T& x, const T& y)
{
return x > y;
}
};
template<class Comapre, class T>
class A//A这个类要使用仿函数
{
public:
void func(T xx, T yy)
{
Comapre com;//创建一个 Comapre 类型的对象 com。
cout << "void func(T xx, T yy)" << com(xx, yy) << endl;;
//调用 com(xx, yy)，即调用仿函数的 operator()，比较 xx 和 yy。
}
};
int main()
{
A<less<int>, int> aa1;
aa1.func(1, 2); // 输出 1 < 2 的结果（true）
A<greater<double>, double> aa2;
aa2.func(1.1, 1.0); // 输出 1.1 >1.0 的结果（ture）
}运算结果：
解释：对三个类都加上模版之后，范围更广了
三：仿函数更优的点
1. 更灵活的功能扩展
仿函数：仿函数是一个类对象，可以包含成员变量和成员函数，因此可以在调用时保存状态（例如计数器、配置参数等）。
函数指针：函数指针只能指向一个静态函数，无法保存状态，功能扩展性较差。
2. 更高的性能
仿函数：仿函数通常是内联的（inline），编译器可以优化其调用，减少函数调用的开销。
函数指针：函数指针的调用需要通过指针间接调用，无法内联，性能稍差。
3. 更强的类型安全
仿函数：仿函数是类对象，类型信息在编译时确定，类型安全性更高。
函数指针：函数指针的类型信息较弱，容易出错（例如指向错误类型的函数）。
4. 更好的通用性
仿函数：仿函数可以与模板结合，实现高度通用的代码。例如，STL 中的排序算法 std::sort 可以通过传入不同的仿函数实现升序或降序排序。
函数指针：函数指针的通用性较差，难以与模板结合。
5. 支持运算符重载
仿函数：仿函数可以重载 operator()，使得对象可以像函数一样被调用，语法更直观。
函数指针：函数指针的调用语法较为繁琐。
6. 更易于组合和扩展
仿函数：仿函数可以通过继承、组合等方式扩展功能。
函数指针：函数指针的功能扩展性较差，难以实现复杂的逻辑组合。
