默认参数与函数重载

一、默认参数
在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, int d=5)  错误，未按照从右到左设定默认值。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.h>
  void Add(char x,char y)
  {

      cout<<"字符串是:";
      cout<<x<<y<<endl;
 } 

 void Add(int x,int y)
 {

     cout<<"两数的和是: ";
     cout<<x+y<<endl;
 } 

 void main()
{
     Add('O','k');
     Add(65,100);
}

 

（2）重载函数abs()，求int、float和double类型数据的绝对值。
   #include <iostream.h> 
   int abs(int x)  //求int型数据的绝对值
   {
         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.h> 
   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)
   {
       //自行编制这部分代码
   } 

   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个函数，出现二义性

 

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