白话C++系列（4）-- 函数新特性（默认值、重载、内联）

C++函数新特性

函数参数默认值

有如下函数声明：

void fun(int i, int j = 10, int k = 20);√

void fun(int i, int j = 10, int k) ;X

注意：有默认参数值的参数必须在参数表的最右端

在函数声明时可以带上参数默认值，而在定义时，不建议带上参数默认值。如果在函数定义的时候也写上函数参数默认值，则实际编译时，有的编译器能够编译通过，而有的编译器编译不会通过。

示例：

#include <iostream>

#include<stdlib.h>

using namespace std;

 void fun(int i, int j = 10, int k = 20); //声明一个函数fun，其带有两个参数默认值

 void fun( int i, int j, int k)  //函数fun的定义

{

              cout<< i <<" " << j << " " << k <<endl;

}

int main()

{

              fun(30);

              fun(30,40);

              fun(30,40,50);

              return 0;

}

输出结果如下：

30 10 20
30 40 20
30 40 50

从上面的输出结果，可以得出以下结论：无实参则用默认值，否则实参覆盖默认值

函数重载

什么是函数重载？？？

在相同作用域内，用同一函数名定义的多个函数，但这些多个函数之间的参数个数或参数类型不同，则称这些多个函数就叫重载函数。

比如，定义以下两个函数（功能：取最大值）

int getMax(int x, int y, int z)

{

              //to do;

}

double getMax(double x, double y)

{

              //to do;

}

从上面两个函数可以看到，函数名都一样，但函数的参数个数和参数类型不同，这样两个函数就是重载函数。

思考：编译器如何识别重载的函数？？

实际编译器编译时，经过如下操作：

int getMax(int x, int y, int z)经过编译后得到getMax_int_int_int

double getMax(double x, double y)经过编译后得到getMax_double_double

从上面的编译结果看，编译后会形成一个名称+参数的方式形成一个新的函数名，来区分两个重载函数；而调用过程中，计算机是采用的自动识别方式，即根据你传入的实参类型以及实参个数自动识别后，来调用相应的函数。

注意：关于函数重载的相关内容，这篇博客讲的更加深入： C++的函数重载

内联函数

内联函数与普通函数的区别：

1、内联函数与普通函数在定义方面区别不大

2、内联函数与普通函数在调用方面区别如下：

如果使用主调函数去调用一个普通函数，将进行如下5个步骤：

去调用fun() ->找到fun()的相关函数入口->执行fun()里的相关代码->返回主调函数->主调函数再运行其他代码直到结束

如果使用主调函数去调用内联函数时，编译时将函数体代码和实参替代掉函数调用语句，这样其实是省掉了上面的过程(2)和(4)，这样可以为调用节省很多时间，尤其对循环调用时，将节省更多的时间。

内联函数关键字：inline

inline int max(int a, int b, int c); //声明一个内联函数max

int main()

{

              int i =10, j = 20, k = 30, m;

              m = max(i,j,k);

              cout<< "max = " << m <<endl;

              return 0;

}

实际上去调用max函数时，会化解成什么样的代码呢？来看一下代码展开：

int main()

{

              int i =10, j = 20, k = 30, m;

              int a, b, c;            

              a = i;b = j;c = k;

              if(b > a) a = b;

              if(c > a) a = c;

              m = a;

              cout<< "max = " << m <<endl;

              return 0;

}

思考：为什么不让所有函数都使用内联方式呢？

其实，是基于以下几个方面来考虑的：

1 对于编译器来说，内联编译是建议性的，由编译器决定；

2 作为内联函数来说，要求逻辑必须简单，调用频繁的函数建议适用内联函数

3 递归函数无法成为内联函数

代码实践

使用函数的重载完成返回最大值的方法。

现在有一个数组，定义一个方法getMax()，利用函数的重载，分别实现：

1、随意取出数组中的两个元素，传到方法getMax()中，可以返回较大的一个元素。

2、将整个数组传到方法getMax()中，可以返回数组中最大的一个元素。

完整可执行程序：

#include <iostream>
using namespace std;
/*
  *函数功能：返回a和b的最大值
  *a和b是两个整数
*/
int getMax(int a, int b)
{
return a > b ? a : b;
}

/*
  * 函数功能：返回数组中的最大值
  * arr：整型数组
  * count：数组长度
  * 该函数是对上面函数的重载
*/
int getMax(int *arr,int count)
{
    //定义一个变量并获取数组的第一个元素
int temp=arr[0];
for(int i = 1; i < count; i++)
    {
        //比较变量与下一个元素的大小
        if(temp<arr[i])
        {
            //如果数组中的元素比maxNum大，则获取数组中的值
            temp=arr[i];
        }    
    }
    return temp;
}

int main()
{
    //定义int数组并初始化
    int numArr[3] = {3, 8, 6};

    //自动调用intgetMax(int a, int b)
    cout<<getMax(6,3) <<endl;

    //自动调用返回数组中最大值的函数返回数组中的最大值
    cout<<getMax(numArr,3) <<endl;
    return 0;
}