C++学习笔记–回调函数与仿函数

一、回调函数

1.定义

我们先看百度百科定义：回调函数就是一个被作为参数传递的函数。在C语言中，回调函数只能使用函数指针实现，在C++、Python、ECMAScript等更现代的编程语言中还可以使用仿函数或匿名函数。
为什么需要一个被作为参数传递的函数？ 在实际需求中，往往在一个任务中有多个步骤，但每个步骤又具有不确定的约束，在程序执行到某一个步骤时需要一个约束，而这个约束我们希望不将他写死，交给使用者来决定。举个例子，我们需要对一个数组排序，排序规则由用户在调用排序方法时确定（从大到小或者从小到大），这时可定义一个回调函数作为排序方法的参数之一。

2.例子

我们首先看STL中的sort算法的回调函数使用：

sort(a.begin(), a.end(), compareUp());

其中compareUp()为自定义的仿函数，用来指定排序规则为从小到大。下面我们自己实现使用回调函数和仿函数定义排序规则，以冒泡排序为例。

函数指针

前面定义说到，在C语言中使用函数指针来实现回调函数，我们先来看看什么是函数指针。函数指针是指向函数的指针变量，即首先它是一个指针变量，我们可以将函数的地址传给指针变量，通道指针来间接调用函数。

bool (*compare)(int, int);//函数指针定义

compare是一个指针，它指向一个参数列表类型为（int, int), 返回值为bool类型的函数，我们可以对它进行初始化：

compare=compareUp;

或者

compare=&compareUp;

compareUp是一个确定的函数，我们将这个函数的地址赋给函数指针。

利用函数指针实现回调函数

首先我们定义两个排序规则的函数：

//回调函数 从小到大排序
inline bool compareUp(int& val1, int& val2)//声明为内联函数可以加快调用速度
{
	if (val1>val2)
	{
		return true;
	}
	return false;
}
//回调函数 从大到小排序
inline bool compareDown(int& val1, int& val2)
{
	if (val1 < val2)
	{
		return true;
	}
	return false;
}

实现冒泡排序的函数：

void bubbleSort(vector<int>& arr, bool (*compare)(int&, int&))//将函数指针作为排序函数的参数，它接收一个函数的地址
{
	for (int i = 0; i < arr.size(); i++)
	{
		for (int j = i + 1; j < arr.size(); j++)
		{
			if (compare(arr[i], arr[j]))
			{
				int tmp = arr[i];
				arr[i] = arr[j];
				arr[j] = tmp;
			}
		}
	}
}

测试我们的冒泡排序，先定义一个打印vector<int>类型的函数printVectotInt

void printVectorInt(vector<int>& v) {
	for (vector<int>::iterator it=v.begin();it!=v.end();it++)//遍历打印vector
	{
		cout << *it << " ";
	}
	cout << endl;
}

测试：

void test01() {
	vector<int>a = { 2,3,5,7,12,34,16,8,17 };
	bubbleSort(a, compareUp);
	printVectorInt(a);
	bubbleSort(a, compareDown);
	printVectorInt(a);
}
int main() {

	test01();
	system("pause");
	return EXIT_SUCCESS;
}

结果

另外，在我们不想声明定义一个过于简单的函数时，可以使用lambda表达式(匿名函数)，匿名函数也可以传入函数指针中使用：

void test02() {
	//使用匿名函数作为函数指针
	vector<int>b = { 9,3,5,23,12,34,16,8,20 };
	cout << "从小到大排序(匿名函数)" << endl;
	bubbleSort(b, [](int& v1, int& v2) { return v1 > v2 ? true : false; });
	printVectorInt(b);
}

二、仿函数

1.定义

顾名思义，仿函数即仿照的函数，表示它功能与函数类似但并不是真正的函数，仿函数又叫函数对象。在C++中它通过重载函数调用运算符即 （）运算符，还是以排序规则为例：

//定义排序规则的仿函数类--从小到大
class compareUp
{
public:
	bool operator()(const int& val1, const int& val2) const {//定义为常函数
		if (val1>val2)
		{
			return true;
		}
		return false;
	}
};
//定义排序规则的仿函数类--从大到小
class compareDown
{
public:
	bool operator()(const int& val1, const int& val2) const {
		if (val1 < val2)
		{
			return true;
		}
		return false;
	}
};

在仿函数的类中，通常不需要定义构造函数和析构函数，这将由系统帮我们自动完成。值得一提的是，我们最好将重载（）的函数定义为常函数，这表明我们并不会改变传入的参数，避免一些麻烦。

2.使用仿函数来实现回调函数

下面使用仿函数来实现回调，我们定义一个compareUp或compareDown的匿名对象作为冒泡排序函数的参数。由于我们事先不知道传入的是什么类，所以实现排序函数需要使用模板函数：

template<class T>
void bubbleSort(vector<int>& arr, const T& compare) {
	for (int i = 0; i < arr.size(); i++)
	{
		for (int j = i + 1; j < arr.size(); j++)
		{
			if (compare(arr[i], arr[j]))
			{
				int tmp = arr[i];
				arr[i] = arr[j];
				arr[j] = tmp;
			}
		}
	}
}

测试：

void test01() {
	vector<int>a= { 2,3,5,7,12,34,16,8,17 };
	cout << "从小到大排序： " << endl;
	bubbleSort(a, compareDown());//仿函数是一个匿名对象
	printVectorInt(a);
	cout << "从大到小排序： " << endl;
	bubbleSort(a, compareUp());
	printVectorInt(a);
}
int main() {

	test01();
	system("pause");
	return EXIT_SUCCESS;
}

结果：

总结

使用回调函数（函数指针实现）与使用仿函数优缺点比较

1.当需要回调的功能函数比较简单时，通常声明为内联函数，这时函数调用将被展开，此时与仿函数性能差别不大；但是使用函数指针实现的回调函数它终究是函数，如果我们需要保留某些状态，这时函数无法实现，因为在函数调用结束后，内部数据都被释放了。而仿函数可以做到这一点，例如我们需要实现记录某一个回调逻辑在程序运行中被调用了多少次，这在普通函数内只能通过一些外部的静态变量来实现；而在仿函数中，我们可以通过给类添加属性，来记录一些状态，而不是使用外部的变量。
2.当需要回调的功能函数比较复杂时，此时回调函数作为一个函数指针传入，其代码亦无法展开。而仿函数则不同。虽然功能函数本身复杂不能展开，但是对仿函数的调用是编译器编译期间就可以确定并进行inline展开的。因此在这种情形下，仿函数比之于回调函数，有着更好的性能。

参考
[1]: http://blog.csdn.net/xushiweizh/article/details/1519828
[2]: https://baike.baidu.com/item/%E5%9B%9E%E8%B0%83%E5%87%BD%E6%95%B0/7545973?fr=aladdin