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
",result); 
} 
 
int main() 
{ 
      pass_func_pointer(add); 
      pass_func_pointer(minus); 
      pass_func_pointer(multiply); 
      pass_func_pointer(divide); 
      return 0; 
} 

使用函数指针作为返回值：

对于以下形式：

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(1); 
 
      } 
 
} 
 
  
 
int main() 
 
{ 
 
      float a=10,b=5; 
 
      char ops[]={'+','-','*','\'}; 
 
      int len=strlen(ops); 
 
      int i=0; 
 
      float (*returned_function_pointer)(float,float); 
 
      for(i=0;i<len;i++) 
 
      { 
 
             returned_function_pointer=FunctionMap(ops[i]); 
 
             printf("the result caculated by the operator %c is %f
",ops[i],returned_function_pointer(a,b)); 
 
      } 
 
      return 0; 
 
} 

使用函数指针数组：

定义一个指向函数指针类型为：float (*)(float,float)的函数指针数组，数组长度为10.正确的形式为：

float(* pFunctionArray[10])(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[4])(float,float)={add,minus,multiply,divide}; 
      int i=0; 
      float a=10.0,b=5.0; 
 
      for(i=0;i<4;i++) 
      { 
             printf("result is %f
",func_pointers[i](a,b)); 
      } 
      return 0; 
} 

使用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[10];

//在定义函数指针类型参数时可以这样定义：
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(3,2); // 5 

函数指针版本是：

int AddFunc(int a, int b)  
{  
return a + b;  
}  
typedef int (*Add) (int a, int b);  
Add add = &AddFunc;  
cout << add(3,2); // 5 

既然C++函数对象与函数指针在使用方式上没什么区别，那为什么要用函数对象呢？很简单，函数对象可以携带附加数据，而指针不行。