C++的面向对象学习(2)：函数的参数默认值、占位参数、函数重载

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

一、高级应用之：可以给函数的参数赋默认值

int add(int a, int b=0, int c=1) {
    return a + b + c;
}

定义了一个名为 add 的函数，它接受三个整数参数 a、b 和 c，并返回它们的和。

在函数定义中，参数 b 和 c 都有默认值，分别为 0 和 1。这意味着在调用 add 函数时，如果不提供 b 和 c 的值，它们将使用默认值。

以下是一个示例，展示了如何调用 add 函数：

int result1 = add(5);          // 使用默认值，相当于 add(5, 0, 1)
int result2 = add(5, 10);      // 使用提供的值，相当于 add(5, 10, 1)
int result3 = add(5, 10, 15);  // 使用提供的值，相当于 add(5, 10, 15)

在上述示例中，我们分别调用了 add 函数三次，每次传递不同数量的参数。第一次调用只提供了 a 的值，而 b 和 c 使用了默认值。第二次调用提供了 a 和 b 的值，而 c 使用了默认值。第三次调用提供了 a、b 和 c 的值。

①注意事项：int add(int a, int b=0, int c)是非法的，如果第二个参数赋默认值了，那么后面的参数也必须都赋默认值。

②注意事项：函数如果声明时参数有默认值，那么其定义时就不能有默认参数。(声明和定义，二者只能有其一的参数有默认值)

int func(int a=0,int b =1);

int func(int a=0,int b=1){
	return a+b;
}

//主程序
func(5,10);//会报错，因为声明与定义同时对参数进行了默认值赋值。

二、高级应用之：函数的占位参数

函数的占位参数是指在函数参数列表中使用一个没有名称的参数，通常使用下划线 _ 表示。占位参数的作用是占据一个参数位置，但在函数实现中并不使用该参数。

以下是一个示例，展示了如何在函数参数列表中使用占位参数：

void print(int x, int y, _) {
    cout << "x = " << x << ", y = " << y << endl;
}

int main() {
    print(1, 2, 3);  // 输出：x = 1, y = 2
    return 0;
}

在上述示例中，我们定义了一个名为 print 的函数，它接受三个参数 x、y 和占位参数 _。在函数实现中，我们只输出了 x 和 y 的值，而没有使用占位参数 _。

需要注意的是，占位参数只能在函数声明或定义中使用，而不能在函数调用时使用。因为在函数调用时，必须提供所有的参数值，不能省略任何一个参数。

函数的占位参数有什么用呢？——一般不建议使用

答：
1.忽略某些参数：有时候在函数实现中，并不需要使用所有的参数，但是函数的接口要求必须提供这些参数。使用占位参数可以在函数定义中占据这些参数的位置，而不使用它们。

2.避免编译器警告：在某些情况下，编译器可能会发出未使用参数的警告。使用占位参数可以在函数定义中占据这些参数的位置，避免编译器警告。

3.保持函数签名一致：有时候在函数重载时，为了保持函数签名一致，可能需要在某个版本的函数中使用占位参数。

三、高级应用之：函数的重chong载（重点技术）

1.函数重载最大的作用：让函数名相同，提高复用性

函数重载是指在同一个作用域内，可以定义多个同名但参数列表不同的函数。通过函数重载，可以根据不同的参数类型或参数个数来调用不同的函数实现。

函数重载的特点如下：

1.同一作用域下，函数名称相同：重载的函数必须具有相同的名称。

2.参数列表不同：重载的函数必须具有不同的参数列表，可以是参数类型不同、参数个数不同或参数顺序不同。

3.返回类型不同不足以区分函数重载：函数重载不能仅通过返回类型的不同来区分，因为函数调用时通常只根据参数列表来确定调用哪个函数。

以下是一个函数重载的示例：

比如我想实现一个计算器的加法功能，但是对于函数add()，里面的参数可能有很多种情况，有可能是两个整形，或者三个浮点型，或者四个双精度浮点型。我为了好记，想都通过add这个函数名来调用实现，那么函数的传参肯定就不能是相同的了。这就要用到重载来实现。

// 函数重载示例
int add(int a, int b) {
    return a + b;
}

double add(double a, double b) {
    return a + b;
}

int add(int a, int b, int c) {
    return a + b + c;
}

int main() {
    int result1 = add(1, 2);             // 调用第一个 add 函数
    double result2 = add(1.5, 2.5);      // 调用第二个 add 函数
    int result3 = add(1, 2, 3);          // 调用第三个 add 函数
    return 0;
}

在上述示例中，我们定义了三个同名但参数列表不同的 add 函数。

根据不同的参数类型和参数个数，编译器可以确定调用哪个函数。

2.函数重载需要注意的事项

①如果与引用别名结合起来

②如果与参数默认值结合起来

int add(int a, int b=0, int c=1) {//带默认值的函数add

    return a + b + c;
}

int add(int a, int b, int c) {//不带默认值，但与第一个参数相同的函数add
    return a + b + c;
}


float add(float& a, float& b) {//引用变量别名的重载函数add
    return a + b;
}

float add(const float& a, const float& b) {//重载函数四，const修饰别名时，与第三个函数也不同
    return a + b;
}

int main() {

    float a = 3.14, b = 1.28;
    add(5);//调用的是函数一
    add(5,3,2);//调用的是函数二
    add(a,b);//调用的是函数三
    add(1,5);//调用的是函数四
    system("pause");
    return 0;
}

int add(int a, int b=0, int c=1)：这是一个重载函数，它接受三个整数参数 a、b 和 c，其中 b 和 c 都有默认值。如果在函数调用时没有提供 b 和 c 的值，它们将分别使用默认值 0 和 1。函数返回 a + b + c 的结果。

int add(int a, int b, int c)：这是另一个重载函数，它接受三个整数参数 a、b 和 c，没有默认值。这个函数与第一个函数的参数列表相同，但没有默认值。函数返回 a + b + c 的结果。

float add(float& a, float& b)：这是另一个重载函数，它接受两个浮点数引用参数 a 和 b。函数返回 a + b 的结果。

float add(const float& a, const float& b)：这是第四个重载函数，它接受两个常量浮点数引用参数 a 和 b。函数返回 a + b 的结果。

main() 函数：在 main 函数中，我们定义了两个浮点数变量 a 和 b，并分别赋值为 3.14 和 1.28。然后我们调用了四次 add 函数：

第一次调用 add(5)，这里只提供了一个整数参数，根据函数重载的规则，编译器会调用 int add(int a, int b=0, int c=1)，其中 a 的值为 5，而 b 和 c 使用默认值。所以函数返回 5 + 0 + 1 = 6。
第二次调用 add(5, 3, 2)，这里提供了三个整数参数，根据函数重载的规则，编译器会调用 int add(int a, int b, int c)，其中 a、b 和 c 的值分别为 5、3 和 2。所以函数返回 5 + 3 + 2 = 10。
第三次调用 add(a, b)，这里提供了两个浮点数引用参数，根据函数重载的规则，编译器会调用 float add(float& a, float& b)，其中 a 和 b 的值分别为 3.14 和 1.28。所以函数返回 3.14 + 1.28 = 4.42。
第四次调用 add(1, 5)，这里提供了两个整数参数，根据函数重载的规则，编译器会调用 float add(const float& a, const float& b)，其中 a 和 b 的值分别为 1 和 5。所以函数返回 1 + 5 = 6。