仿函数 VS 函数指针实现回调

前提：

        本博客对比 函数指针实现回调 和  仿函数 ，突出仿函数的优势。

目的：

        一个类要能够灵活的调用两个函数，essfc 和 greaterfc，分别用于比较两个整数的大小：

①：lessfc：判断 x 是否小于 y，如果是则返回 true，否则返回 false。

②：greaterfc：判断 x 是否大于 y，如果是则返回 true，否则返回 false

一：函数指针实现回调

①：普通代码：

//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函数 且传两个intA aa2(greaterfc);//创建一个对象aa2.func(1, 2);//调用对象的func函数 且传两个int
}

运行结果：

解释：

类 A 的行为可以通过传入不同的函数指针来动态改变：

        传入 lessfc 时，func 方法会执行小于比较。

        传入 greaterfc 时，func 方法会执行大于比较。

②：加上模版的代码：

//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()

①：普通代码：

//定义仿函数
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>，就是对仿函数进行显式的调用，此时的模版不再是简单的类型，而是一个类

②：加上模版的代码：

//定义仿函数
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. 更易于组合和扩展
仿函数：仿函数可以通过继承、组合等方式扩展功能。

函数指针：函数指针的功能扩展性较差，难以实现复杂的逻辑组合。