c++函数指针

1，函数指针

定义
一个指向函数的指针，通过该指针可以动态调用该函数，这个指针指向的是函数的地址。

语法
返回类型（*指针变量名）（参数1，参数2，…）；

1.1 创建一个函数指针

示例如下

int add(const int val1,const int val2)
{
	return val1 +val2;
}

//func就是这个指针
int (*func)(const int ,const int) = add;

int main()
{
	cout<<func(2,5)<<endl;//打印结果为7
}

1.2 使用函数指针

上面的示例看起来好像和普通调用没有什么区别，但是函数指针他作为一个指针，是可以当作参数去使用的，例如。

int add(const int val1, const int val2){return val1 + val2;}
int sub(const int val1, const int val2){return val1 - val2;}

//第一个参数为函数指针，函数返回值为int，参数为const int,const int
//第二个参数为const int
//第三个参数为const int
void compute(int (*func)(const int, const int) , const int val1, const int val2)
{
	cout << func(val1, val2) << endl;;
}

int main()
{
	//创建一个函数指针，并且为他赋值
	int (*func)(const int, const int);
	func = add;
	compute(func, 2, 5);//打印结果为7

	func = sub;
	compute(func, 2, 5);//打印结果为-3
}

1.3 typedef为函数指针创建别名

上面的示例中通过为函数指针赋值，调用了不同的函数，结果自然也不相同，但过程还是有些繁琐，再简化一下。

int add(const int val1, const int val2){return val1 + val2;}
int sub(const int val1, const int val2){return val1 - val2;}

//typedef为类型创建别名，也就是说函数指针的类型为func
typedef int (*func)(const int,const int);
//函数的第一个参数为func类型的函数指针
void compute(func fun, const int val1, const int val2)
{
	cout << fun(val1, val2) << endl;;
}

int main()
{
	//compute的参数为不同的函数
	compute(add, 2, 5);//打印结果为7
	compute(sub, 2, 5);//打印结果为-3
}

1.3 using为函数指针创建别名

通过typedef为函数指针创建别名后，使用起来会相对简介明了，但是c++11引入using相对于typedef在功能上做出了更多的补充。
创建别名时
1，语法更加简介。
2，支持模板。

1.3.1 语法优化

通过赋值运算符的形式来为类型创建别名

typedef int (*func)(const int,const int);
using Ufunc = int (*)(const int, const int);

//函数的第一个参数为func类型的函数指针
void compute(Ufunc fun, const int val1, const int val2)
{
	cout << fun(val1, val2) << endl;;
}

int main()
{
	//compute的参数为不同的函数
	compute(add, 2, 5);//打印结果为7
	compute(sub, 2, 5);//打印结果为-3
}

1.3.1 支持模板

创建别名很大程度上提高了代码的简洁性，但是在涉及到模板时，typedef就无法使用了，通过using去为函数指针创建别名。

template<typename T>
typedef T (*func)(const T,const T);//是不被允许的
typedef int (*func)(const int,const int);//需要明确类型才可以

//使用using----------------------
int add(const int val1, const int val2) { return val1 + val2; }
double add(const double val1, const double val2) { return val1 + val2; }

template<typename T>
using Ufunc = T(*)(const T, const T);//允许

template<typename T>
void compute(Ufunc<T> fun, const T val1, const T val2)
{
	cout << fun(val1, val2) << endl;;
}

int main()
{
	Ufunc<int> fun = add;
	compute(fun, 2, 5);
	Ufunc<double> fun2 = add;
	compute(fun2, 2.3, 5.4);
}