C++学习笔记（八）：函数重载、函数指针和函数对象

函数重载

函数重载是指在同一作用域内，可以有一组具有相同函数名，不同参数列表的函数，这组函数被称为重载函数。重载函数通常用来命名一组功能相似的函数，这样做减少了函数名的数量，避免了名字空间的污染，对于程序的可读性有很大的好处。

1. 试想如果没有函数重载机制，如在C中，你必须要这样去做：为这个print函数取不同的名字，如print_int、print_string。这里还只是两个的情况，如果是很多个的话，就需要为实现同一个功能的函数取很多个名字，如加入打印long型、char*、各种类型的数组等等。这样做很不友好！
2. 类的构造函数跟类名相同，也就是说：构造函数都同名。如果没有函数重载机制，要想实例化不同的对象，那是相当的麻烦！
3. 操作符重载，本质上就是函数重载，它大大丰富了已有操作符的含义，方便使用，如+可用于连接字符串等！

两个重载函数必须在下列一个或两个方面有所区别：

1. 函数有不同参数。
2. 函数有不同参数类型。

返回值不作为判断两个函数区别的标志。

C++运算符重载的相关规定如下：

1. 不能改变运算符的优先级；
2. 不能改变运算符的结合型；
3. 默认参数不能和重载的运算符一起使用；
4. 不能改变运算符的操作数的个数；
5. 不能创建新的运算符，只有已有运算符可以被重载；
6. 运算符作用于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指针调用时调用这个函数，普通对象或普通引用调用时调用上面一个。

函数指针

函数指针（或称为回调函数）是一个很有用也很重要的概念。当发生某种事件时，其它函数将会调用指定的函数指针指向的函数来处理特定的事件。

注意：定义的一个函数指针是一个变量。

定义一个函数指针：

两种格式：

1. 返回类型 (*函数指针名称)(参数类型,参数类型,参数类型，…);
2. 返回类型 （类名称::*函数成员名称）（参数类型，参数类型，参数类型，….）

示例：

 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;

上面这段代码说明了两个问题：

1. 一个函数指针可以多次赋值。
2. 取地址符号是可选的，却是推荐使用的。

调用：

 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)

其具体含义就是，声明了这样一个函数：

1. 其名称为func，其参数的个数为1个；
2. 其各个参数的类型为：op—char；
3. 其返回变量（函数指针）类型为：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++函数对象与函数指针在使用方式上没什么区别，那为什么要用函数对象呢？很简单，函数对象可以携带附加数据，而指针不行。