函数重载
函数重载是指在同一作用域内，可以有一组具有相同函数名，不同参数列表的函数，这组函数被称为重载函数。重载函数通常用来命名一组功能相似的函数，这样做减少了函数名的数量，避免了名字空间的污染，对于程序的可读性有很大的好处。
- 试想如果没有函数重载机制，如在C中，你必须要这样去做：为这个print函数取不同的名字，如print_int、print_string。这里还只是两个的情况，如果是很多个的话，就需要为实现同一个功能的函数取很多个名字，如加入打印long型、char*、各种类型的数组等等。这样做很不友好！
- 类的构造函数跟类名相同，也就是说：构造函数都同名。如果没有函数重载机制，要想实例化不同的对象，那是相当的麻烦！
- 操作符重载，本质上就是函数重载，它大大丰富了已有操作符的含义，方便使用，如+可用于连接字符串等！
两个重载函数必须在下列一个或两个方面有所区别：
- 函数有不同参数。
- 函数有不同参数类型。
返回值不作为判断两个函数区别的标志。
C++运算符重载的相关规定如下：
- 不能改变运算符的优先级；
- 不能改变运算符的结合型；
- 默认参数不能和重载的运算符一起使用；
- 不能改变运算符的操作数的个数；
- 不能创建新的运算符，只有已有运算符可以被重载；
- 运算符作用于C++内部提供的数据类型时，原来含义保持不变。
总结示例：
（1）普通函数(非类成员函数)形参完全相同，返回值不同，如：
void print();
int print(); //不算重载，直接报错
（2）普通函数形参为非引用类型，非指针类型，形参一个带const，一个不带const
void print(int x);
void print(const int x); //不算重载，直接报错重定义
（3）普通函数形参为引用类型或指针类型，一个形参带const，一个不带const
void print(int *x);
void print(const int *x); //算重载，执行正确，实参为const int *时候调用这个，为int* 的时候调用上面一个 void print(int &x);
void print(const int &x); //算重载，执行正确，实参为const int &时候调用这个，为int& 的时候调用上面一个
（4）类的成员函数，形参完全相同，一个函数为const成员函数，一个函数为普通成员函数
void print();
void print() const; //算重载。const对象或const引用const指针调用时调用这个函数，普通对象或普通引用调用时调用上面一个。
函数指针
函数指针（或称为回调函数）是一个很有用也很重要的概念。当发生某种事件时，其它函数将会调用指定的函数指针指向的函数来处理特定的事件。
注意：定义的一个函数指针是一个变量。
定义一个函数指针：
两种格式：
- 返回类型 (*函数指针名称)(参数类型,参数类型,参数类型，…);
- 返回类型 （类名称::*函数成员名称）（参数类型，参数类型，参数类型，….）
示例：
int (*pFunction)(float,char,char)=NULL;//C语言的函数指针
int (MyClass::*pMemberFunction)(float,char,char)=NULL;//C++的函数指针，非静态函数成员
int (MyClass::*pConstMemberFunction)(float,char,char) const=NULL;//C++的函数指针，静态函数成员
C函数指针赋值和调用：
赋值：
int func1(float f,int a,int b){return f*a/b;}
int func2(float f,int a,int b){return f*a*b;}
//然后我们给函数指针pFunction赋值
pFunction=func1;
pFunction=&func2;
上面这段代码说明了两个问题：
- 一个函数指针可以多次赋值。
- 取地址符号是可选的，却是推荐使用的。
调用：
pFunction(10.0,’a’,’b’);
(*pFunction)(10.0,’a’,’b’);
C++类里的函数指针赋值和调用：
定义类：
MyClass
{
public:
int func1(float f,char a,char b)
{
return f*a*b;
}
int func2(float f,char a,char b) const
{
return f*a/b;
}
}
赋值：
MyClass mc;
pMemberFunction= &mc.func1;//必须要加取地址符号
pConstMemberFunction = &mc.func2;
调用：
(mc.*pMemberFunction)(10.0,’a’,’b’);
(mc.*pConstMemberFunction)(10.0,’a’,’b’);
函数指针作为参数：
#include<stdio.h>
float add(float a,float b){return a+b;}
float minus(float a,float b){return a-b;}
float multiply(float a,float b){return a*b;}
float divide(float a,float b){return a/b;}
int pass_func_pointer(float (*pFunction)(float a,float b))
{
float result=pFunction(10.0,12.0);
printf("result=%f\n",result);
}
int main()
{
pass_func_pointer(add);
pass_func_pointer(minus);
pass_func_pointer(multiply);
pass_func_pointer(divide);
return ;
}
使用函数指针作为返回值：
对于以下形式：
float (* func(char op) ) (float ,float)
其具体含义就是，声明了这样一个函数：
- 其名称为func，其参数的个数为1个；
- 其各个参数的类型为：op—char；
- 其返回变量（函数指针）类型为：float(*)(float,float)
示例：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
float add(float a,float b){return a+b;}
float minus(float a,float b){return a-b;}
float multiply(float a,float b){return a*b;}
float divide(float a,float b){return a/b;}
float(* FunctionMap(char op) )(float,float)
{
switch(op)
{
case '+':
return add;
break;
case '-':
return minus;
break;
case '*':
return multiply;
break;
case '\\':
return divide;
break;
default:
exit();
}
}
int main()
{
float a=,b=;
char ops[]={'+','-','*','\\'};
int len=strlen(ops);
int i=;
float (*returned_function_pointer)(float,float);
for(i=;i<len;i++)
{
returned_function_pointer=FunctionMap(ops[i]);
printf("the result caculated by the operator %c is %f\n",ops[i],returned_function_pointer(a,b));
}
return ;
}
使用函数指针数组：
定义一个指向函数指针类型为：float (*)(float,float)的函数指针数组，数组长度为10.正确的形式为：
float(* pFunctionArray[])(float,float)
示例：
#include<stdio.h>
float add(float a,float b){return a+b;}
float minus(float a,float b){return a-b;}
float multiply(float a,float b){return a*b;}
float divide(float a,float b){return a/b;}
int main()
{
float(*func_pointers[])(float,float)={add,minus,multiply,divide};
int i=;
float a=10.0,b=5.0;
for(i=;i<;i++)
{
printf("result is %f\n",func_pointers[i](a,b));
}
return ;
}
使用typedef进行简化：
typedef一般使用形式如下：
typedef int bool;
这在C语言中很常用，由于C语言中没有bool类型，这样定义之后可以从形式上引入一个bool类型，提高代码可读性。
然而在使用typedef定义函数指针类型的时候，和普通的使用typedef引入新类型的方式不一样。
在我们要将float (*)(float,float)类型声明为一种新类型，应该是：
typedef float(*fpType)(float,float);
这样我们就可以用fpType来表示float (*)(float,float)这种类型了，使用如下：
fpType pFunction; //在定义函数指针数组的时候可以这样定义：
fpType pFunctions[]; //在定义函数指针类型参数时可以这样定义：
void func(fpType pFunction); //在定义函数指针类型的返回值时可以这样定义：
fpType func(int a);
函数对象
函数对象实质上是一个实现了operator()括号操作符的类。
class Add
{
public:
int operator()(int a, int b)
{
return a + b;
}
};
Add add; // 定义函数对象
cout << add(,); // 5
函数指针版本是：
int AddFunc(int a, int b)
{
return a + b;
}
typedef int (*Add) (int a, int b);
Add add = &AddFunc;
cout << add(,); // 5
既然C++函数对象与函数指针在使用方式上没什么区别，那为什么要用函数对象呢？很简单，函数对象可以携带附加数据，而指针不行。