函数的重载与默认参数的使用与错误纠正

目录

 

函数的重载

函数的重载是什么？

函数重载的要求

函数重载举例

函数的默认参数

函数的重载与函数的默认参数的区别

函数默认参数有何用处

由以上示例，我们要注意哪些事项呢？

函数的重载与函数的默认参数一起使用会发生什么？

---

函数的重载

函数的重载是什么？

我们需要的函数一般要有普适性，就是对于一类问题有处理能力，比如：我想要找出两个float变量的最大值，或者两个int型变量的最大值。这种一种函数实现一类功能的情况就叫做函数的重载。

函数重载的要求

既然要使得一个函数针对不同形参实现不同功能，那我们该如何正确的重载呢：

保证函数重载的形参不同，即参数的顺序，参数的数据类型，参数的个数三者中至少有一个是不同的才可以。

大家又说“为什么仅函数返回值不同不行呢？”

函数一般可以通过指针与引用来修改传入参数的值，因此函数有时可不需要返回值，那么函数的返回值类型已不是函数重载的重要条件。

函数重载举例

#include <iostream>  
using namespace std;  
  
// 函数通过形参的地址改变形参，无需返回值  
int get_max_min(int x, int y, int *z)  
{  
    *z = x > y ? x : y;  
    return 0;  
}  
float get_max_min(float x, float y, float *z)  
{  
    *z = x > y ? x : y;  
    return 0;  
}  
  
int main()  
{  
    float x = 9.7, y = 6.3, z = 0;  
    get_max_min(x, y, &z);  
    cout << "z=" << z << endl;  
} 

 

函数的默认参数

函数的重载与函数的默认参数的区别

相同点：

函数的重载与函数的默认参数都可以实现函数对于一类问题的处理，因此两者不可同时对同一函数使用，这样的话系统执行时会报错。

不同点：

① 函数的重载可以使得同名函数根据不同形参个数，不同形参顺序，不同形参类型实现不同功能，而函数的默认参数仅可以使函数根据不同形参个数实现不同功能；

② 函数的重载是在编写多个重名函数，而函数的默认参数是在一个函数内实现的。

函数默认参数有何用处

我想要实现一个函数可以根据输入变量来输出数组内的最大值 或 最小值 或 最大值和最小值，如下示例：

① 输出数组内的最大值与最小值

#include <iostream>  
using namespace std;  
  
void get_min_max(int *num, int length, int *num_max, int *num_min)  
{  
    if ((length < 0) || (num_max && num_min))  
    {  
        return;  
    }  
    int max_num = 0, min_num = 0, i = 0;  
    for (; i < length; i++)  
    {  
        if (max_num < num[i])  
        {  
            max_num = num[i];  
        }  
        if (min_num > num[i])  
        {  
            min_num = num[i];  
        }  
    }  
    if (num_max != NULL)  
    {  
        *num_max = max_num;  
    }  
    if (num_min != NULL)  
    {  
        *num_min = min_num;  
    }  
}  
  
int main()  
{  
    int *iarray, max_num = 0, min_num = 0;  
    iarray = new int[10]{ 34,87,2,90,1,-4,67,32,4,12 };  
    get_min_max(iarray, 10, &max_num, &min_num);  
    cout << "max_num = " << max_num << "; min_num = " << min_num << endl;  
} 

 

② 仅输出数组的最小值

#include <iostream>  
using namespace std;  
  
// 采用默认参数，添加默认参数的形参一定单独要在最后一部分，不可以和无默认参数的形参混合声明  
void get_min_max(int *num, int length, int *num_max = NULL, int *num_min = NULL)  
{  
    if ((length < 0) || (num_max && num_min))  
    {  
        return;  
    }  
    int max_num = 0, min_num = 0, i = 0;  
    for (; i < length; i++)  
    {  
        if (max_num < num[i])  
        {  
            max_num = num[i];  
        }  
        if (min_num > num[i])  
        {  
            min_num = num[i];  
        }  
    }  
    if (num_max != NULL)  
    {  
        *num_max = max_num;  
    }  
    if (num_min != NULL)  
    {  
        *num_min = min_num;  
    }  
}  
  
int main()  
{  
    int *iarray, min_num = 0;  
    iarray = new int[10]{ 34,87,2,90,1,-4,67,32,4,12 };  
    get_min_max(iarray, 10, NULL, &min_num);  // 由于NULL在中间，因此不可以省略不写
    cout << "min_num = " << min_num << endl;  
}

 

③ 仅输出最大值

#include <iostream>  
using namespace std;  
  
// 采用默认参数，添加默认参数的形参一定单独要在最后一部分，不可以和无默认参数的形参混合声明  
void get_min_max(int *num, int length, int *num_max = NULL, int *num_min = NULL)  
{  
    if ((length < 0) || (num_max && num_min))  
    {  
        cout << "参数输入异常" << endl;  
        return;  
    }  
    int max_num = 0, min_num = 0, i = 0;  
    for (; i < length; i++)  
    {  
        if (max_num < num[i])  
        {  
            max_num = num[i];  
        }  
        if (min_num > num[i])  
        {  
            min_num = num[i];  
        }  
    }  
    if (num_max != NULL)  
    {  
        *num_max = max_num;  
    }  
    if (num_min != NULL)  
    {  
        *num_min = min_num;  
    }  
}  
  
int main()  
{  
    int *iarray, max_num = 0;  
    iarray = new int[10]{ 34,87,2,90,1,-4,67,32,4,12 };  
    get_min_max(iarray, 10, &max_num);  // 由于后面为NULL，故省略不写
    cout << "max_num = " << max_num << endl;  
} 

 

 

由以上示例，我们要注意哪些事项呢？

① 有默认参数的形参一定要单独写一块，在函数的形参中先写不带默认参数的形参，再写带默认参数的形参；

② 重载和默认参数不可对同一函数使用，否则会发生错误；

③ 从函数编译实现角度而言，重载是在函数体外部实现的，默认参数是在函数体内部实现的，因此默认参数比重载要复杂一些。

函数的重载与函数的默认参数一起使用会发生什么？

#include <iostream>  
using namespace std;  
  
// 采用默认参数，添加默认参数的形参一定单独要在最后一部分，不可以和无默认参数的形参混合声明  
void get_min_max(int *num, int length, int *num_max = NULL, int *num_min = NULL)  
{  
    if ((length < 0) || (num_max && num_min))  
    {  
        cout << "参数输入异常" << endl;  
        return;  
    }  
    int max_num = 0, min_num = 0, i = 0;  
    for (; i < length; i++)  
    {  
        if (max_num < num[i])  
        {  
            max_num = num[i];  
        }  
        if (min_num > num[i])  
        {  
            min_num = num[i];  
        }  
    }  
    if (num_max != NULL)  
    {  
        *num_max = max_num;  
    }  
    if (num_min != NULL)  
    {  
        *num_min = min_num;  
    }  
}  
  
void get_min_max(int *num, int length) // 函数重载  
{  
    cout << "输入参数不全" << endl;  
}  
  
  
int main()  
{  
    int *iarray, max_num = 0;  
    iarray = new int[10]{ 34,87,2,90,1,-4,67,32,4,12 };  
    get_min_max(iarray, 10, &max_num);  
    cout << "max_num = " << max_num << endl;  
    get_min_max(iarray, 10); // 含有两个参数的函数调用  
} 

 

输出结果：

 

我们从结果中可以看出：

系统区分不了含有两个参数的函数应该执行哪一个，系统直接懵了。