默认参数与函数重载,及函数匹配

一、默认参数
在C++中，可以为参数指定默认值。在函数调用时没有指定与形参相对应的实参时， 就自动使用默认参数。

默认参数的语法与使用：
（1）在函数声明或定义时，直接对参数赋值。这就是默认参数；
（2）在函数调用时，省略部分或全部参数。这时可以用默认参数来代替。

注意：
（1）默认参数只可在函数声明中设定一次。只有在无函数声明时，才可以在函数定义中设定。
（2）默认参数定义的顺序为自右到左。即如果一个参数设定了缺省值时，其右边的参数都要有缺省值。
如：int mal(int a, int b=3, int c=6, int d=8)    正确，按从右到左顺序设定默认值。
        int mal(int a＝6, int b=3, int c＝5, int d)  错误，未按照从右到左设定默认值。c设定缺省值了，而其右边的d没有缺省值。
（3）默认参数调用时，则遵循参数调用顺序，自左到右逐个调用。这一点要与第（2）分清楚，不要混淆。
如：void mal(int a, int b=3, int c=5);      //默认参数
        mal(3, 8, 9 );                                      //调用时有指定参数，则不使用默认参数
        mal(3, 5);                  //调用时只指定两个参数，按从左到右顺序调用，相当于mal(3,5,5);
        mal(3);                      //调用时只指定1个参数，按从左到右顺序调用,相当于mal(5,3,5);
        mal(  );                      //错误，因为a没有默认值
        mal(3,  , 9)               //错误，应按从左到右顺序逐个调用
再如： void mal(int a＝8, int b=3, int c=5);      //默认参数
             mal(  );                                                      //正确，调用所有默认参数，相当于mal(8,3,5);

（4）默认值可以是全局变量、全局常量，甚至是一个函数。但不可以是局部变量。因为默认参数的调用是在编译时确定的，而局部变量位置与默认值在编译时无法确定。

 

二、函数重载
在相同的声明域中，函数名相同，而参数表不同。通过函数的参数表而唯一标识并且来区分函数的一种特殊的函数用法。

参数表的不同表现为：
1、参数类型不同；
2、参数个数不同；

特别注意：返回类型不同不可以作为函数重载的标识。

例：

#include <iostream> 
using namespace std; 

int test(int a,int b); 
float test(float a,float b); 

void main() 
...{ 
     cout << test(1,2) << endl << test(2.1f,3.14f) << endl; 
     cin.get(); 
} 

int test(int a,int b) 
...{ 
     return a+b; 
} 

float test(float a,float b) 
...{ 
     return a+b; 
} 

在上面的程序中，用了两个名为test的函数来描述int类型和操作的和float类型和操作,方便对相同或者相似功能函数的管理!
那么，计算机该如何来判断同名称函数呢?操作的时候会不会造成选择错误呢?
回答是否定的,c++内部利用一种叫做名称粉碎的机智来内部重命名同名函数,上面的例子在计算重命名后可能会是testii和testff ，他们是通过参数的类型或个数来内部重命名的。

 

1、参数类型不同的例子：
（1）
#include<iostream>

using namespace std;

void Add(char x,char y){ cout << "字符串是:"<<x<<y<<endl; }
void Add(int x,int y){ cout << "两数的和是: "<<x+y<<endl; }
void main()
{
    Add('O','k');
    Add(65,100);
}

 

（2）重载函数abs()，求int、float和double类型数据的绝对值。
#include <iostream>

using namespace std;
//求int型数据的绝对值
int abs(int x)
{
    if (x<0) x=-x;
    return x;
}
//求float型数据的绝对值
float abs(float x)
{
    if (x<0) x=-x;
    return x;
}
//求 double型数据的绝对值
//仿照上面的函数编写

//主函数
void main()
{
   int a=-357;
   float b=63.85;
   double c=-6974.26;
   cout<<abs(a)<<'\t'<<abs(b)<<'\t'<<abs(c)<<endl;

}

 

2、参数个数不同的例子：求2～4个整数当中的最大值，根据参数个数的不同调用不同的max()函数
#include<iostream>

using namespace std;

int max(int x,int y)
{
  if(x>y)

      return x;
   else

      return y;
}
int max(int x,int y,int z)
{
    int a=max(x,y);
    return max(a,z);
}
int max(int a,int b,int c,int d)
{
//自行编制这部分代码
}
void main()
{
    cout<<max(1,2)<<endl;
    cout<<max(1,2,3)<<endl;
    cout<<max(1,2,3,4)<<endl;
}

函数重载的注意事项

1、函数的形参必须不同，或者个数不同，或者类型不同，不能够只依靠函数的返回值类型不同或形参变量名不同来实现函数重载。
2、不要将不同功能的函数定义为重载函数，以免出现对调用结果的误解。如：
int add(int x,int y){return x+y;}
float add(float x,float y){return x-y;}

 

重载函数与默认参数重叠导致的二义性问题：
func(int);                                                                               //重载函数1，只有1个参数，无默认参数
func(int, int =4);                                                                   //重载函数2，有2个参数，有1个默认参数
func(int a=3, int b=4, int c=6);                                          //重载函数3，有3个参数，有3个默认参数
fucn(float a=3.0, float b=4.0 float c=5.0);                               //重载函数4，有3个参数，有3个默认参数
fucn(float a=3.0, float b=4.0 float c=5.0 float d=7.9 );          //重载函数5，有4个参数，有4个默认参数

func(2);                  //可调用前3个函数，出现二义性
func(2.0);              //可调用后2个函数，出现二义性

所以当重载函数与默认参数共同使用时，要注意出现二义性问题。

 

重载函数的调用匹配（二义性问题）
函数调用时从来没有在匹配上冒出过大问题，直到重载概念的到来。因为重载函数允许一批函数共用一个函数名。
　　以往调用函数是依赖函数名的，直接找到对应的函数名，检查一下参数个数和类型是否符合即可。现在就只好凭函数名和参数一起来确定该调用哪个函数了。
　　若是凭参数能唯一确定函数那自然好，可是参数还存在类型转换与区配的问题。这就增加了函数匹配的难度，有时甚至明明有多个函数供选择却找不到能匹配的。
　　书上为重载确定整理了以下几个步骤：“候选函数”、“选择可行函数”、“寻找最佳匹配”。其实这里面真正难以对付的是“寻找最佳匹配”。下面分述之：
　　第一步“候选函数”是凭函数名进行筛选。简单说就是找出所有的同名函数。当然，如果仅仅按是否同名来判断将面临问题，因为函数有不同的作用域。严格说来就是下面这句话：
　　引用：候选函数是与被调用函数同名的函数，并且在调用点上，它的声明可见。
　　第二步“选择可行函数”是按参数的个数进行筛选。参数的个数是明确的条件，这就减少了产生分歧的可能性。当然，分歧还是会有的，那就是有些函数允许缺省参数。比如：
void f(int i);//函数一
void f(int i, int j=0);//函数二
f(1, 2);//调用一
f(1);//调用二
　　以上两个重载函数究竟会不会产生调用分歧，仅凭函数还不能判。如果只有调用一，则它们是没有冲突的，但是如果有调用二，则在调用二的点上会产生“二义性”。
　　第三步是难点，怎样寻找最佳匹配？如果能找到某个重载，它的参数个数和参数类型完全与调用一致，则它就是“最佳”。但是事实上有两种情况会导致不确定性：一是字面值常量没有明确的类型，二是变量的类型可以转换。
　　先说字面值常量，比如“f('a');”的参数就是一个字面值常量。它究竟是char型还是unsigned char型？再比如“f(1);”的参数，它究竟是int、unsigned int、long还是unsigned long？
　　对于变量来说，它有明确的类型，但是如果在可行函数中不存在完全相同的类型，就要面临转换的问题，转换是多种多样的，一个int既可以转为 unsigned int也可以转为long，甚至还可以转化为float或double。那么，多种转换之间就要寻找一个“最佳”。
　　简单地说，除了类型“精确匹配”以外，类型的“提升”是优于“降级”的。那么，能否找到类型的提升就是关键了。对于含有多个参数的函数，有时就更难迁就每一个参数了。比如：
void f(int, int);//函数一
void f(double, double);//函数二
f(42, 2.56);//调用一
　　上面的例子中，对于调用一，两个函数没有哪一个比另一个优。
　　引用：区配成功的条件为有且仅有一个函数满足下列条件：(1)每个实参的匹配都不劣于其它可行函数需要的匹配。(2)至少有一个实参的匹配优于其它可行函数提供的匹配。
　　说到底，重载函数之所以在调用的时候有这么大的麻烦，原因还在于多个函数共用一个函数名。有一点还需要拿出来弹调一下：虽然它们函数名相同，但它们是不同的函数。