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

发布时间:2023年12月20日

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


前言

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

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。

文章来源:https://blog.csdn.net/qq_53092944/article/details/135034525
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。