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

news2025/4/21 2:39:03

前提：

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

目的：

一个类要能够灵活的调用两个函数，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函数 且传两个int

	A 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）
}

运算结果：