C++默认实参

函数默认参数

在C++中,可以为参数指定默认值,C语言是不支持默认参数的,Java也不支持!!!

默认参数的语法与使用:
(1)在函数声明或定义时,直接对参数赋值。这就是默认参数;
(2)在函数调用时,省略部分或全部参数。这时可以用默认参数来代替。

注意事项:

(1)函数默认值只能赋值一次,或者是在声明中,或者是在定义中,如下所示

  1. /*正确*/
  2. #include <iostream>
  3. int f(int a=5);
  4. int f(int a)
  5. {
  6. std::cout <<a<<std::endl;
  7. return a;
  8. }
  9. int main()
  10. {
  11. f();
  12. return 0;
  13. }
  14. /*正确*/
  15. #include <iostream>
  16. int f(int a=5)
  17. {
  18. std::cout <<a<<std::endl;
  19. return a;
  20. }
  21. int main()
  22. {
  23. f();
  24. return 0;
  25. }
  26. /*正确*/
  27. #include <iostream>
  28. int f(int a);
  29. int f(int a=5)
  30. {
  31. std::cout <<a<<std::endl;
  32. return a;
  33. }
  34. int main()
  35. {
  36. f();
  37. return 0;
  38. }
  39. /*错误*/
  40. #include <iostream>
  41. int f(int a=5);
  42. int f(int a=5)
  43. {
  44. std::cout <<a<<std::endl;
  45. return a;
  46. }
  47. int main()
  48. {
  49. f();
  50. return 0;
  51. }
  52. [[email protected] ~]$ make test
  53. g++     test.cpp   -o test
  54. test.cpp: In function ‘int f(int)’:
  55. test.cpp:3: error: default argument given for parameter 1 of ‘int f(int)’
  56. test.cpp:2: error: after previous specification in ‘int f(int)’
  57. make: *** [test] Error 1

(2) 默认参数定义的顺序为自右到左。即如果一个参数设定了缺省值时,其右边的参数都要有缺省值。比如int f(int a, int b=1,int c=2,int d=3)是对的,但是int f(int a,int b=1,int c=2,int d)就是错的。这个的原因很显然,你传几个参数,编译器都认为是从左向右的,比如int f(int a,int b=1,int c),传入了f(1,2),它会认为a=1,b=2,那c呢?所以必须做这个限定。

  1. #include <iostream>
  2. int f(int a,int b);
  3. int f(int a=5,int b)
  4. {
  5. std::cout <<a<<std::endl;
  6. return a;
  7. }
  8. int main()
  9. {
  10. f(6);
  11. return 0;
  12. }
  13. g++     test.cpp   -o test
  14. test.cpp: In function ‘int f(int, int)’:
  15. test.cpp:3: error: default argument missing for parameter 2 of ‘int f(int, int)’
  16. make: *** [test] Error 1

(3)默认参数调用时,则遵循参数调用顺序,自左到右逐个调用。这一点要与第(2)分清楚,不要混淆。

如:void mal(int a, int b=3, int c=5); //默认参数
mal(3, 8, 9 ); //调用时有指定参数,则不使用默认参数
mal(3, 5); //调用时只指定两个参数,按从左到右顺序调用,相当于mal(3,5,5);
mal(5); //调用时只指定1个参数,按从左到右顺序调用v当于mal(5,3,5);
mal( ); //错误,因为a没有默认值
mal(3, , 9) //错误,应按从左到右顺序逐个调用

(4)默认参数可以是全局变量,全局常量,还可以是函数,但是不能是局部变量,因为局部变量在编译时未定

  1. [[email protected] ~]$ cat test.cpp
  2. #include <iostream>
  3. int x = 5;
  4. int f(int a,int b,int c);
  5. int f(int a,int b=5,int c=x)
  6. {
  7. std::cout <<a+b+c<<std::endl;
  8. return a;
  9. }
  10. int f2(int (*func)(int,int,int)=f )
  11. {
  12. func(2,3,5);
  13. return 0;
  14. }
  15. int main()
  16. {
  17. f(1);
  18. f2();
  19. return 0;
  20. }
  21. [[email protected] ~]$ make test && ./test
  22. g++     test.cpp   -o test
  23. 11
  24. 10

但是注意一点,func不能使用默认参数了,因为func是局部变量,它是后来被赋值成f的

  1. [[email protected] ~]$ cat test.cpp
  2. #include <iostream>
  3. int x = 5;
  4. int f(int a,int b,int c);
  5. int f(int a,int b=5,int c=x)
  6. {
  7. std::cout <<a+b+c<<std::endl;
  8. return a;
  9. }
  10. int f2(int (*func)(int,int,int)=f )
  11. {
  12. func(2);
  13. return 0;
  14. }
  15. int main()
  16. {
  17. f(1);
  18. f2();
  19. return 0;
  20. }
  21. [[email protected] ~]$ make test
  22. g++     test.cpp   -o test
  23. test.cpp: In function ‘int f2(int (*)(int, int, int))’:
  24. test.cpp:11: error: too few arguments to function
  25. make: *** [test] Error 1
时间: 2024-11-05 18:30:07

C++默认实参的相关文章

关于默认实参

定义了一个函数f(const string &str, long pos, long count = -1) { //do something } 而在使用时却发生了错误 int main() { string str; long pos = 1; f(str, pos); } 提示信息为 错误 1 error C2664: “string &string::f(const string &,long,long)”: 无法将参数 1 从“string”转换为“long” c:\us

特殊用途语言特性:默认实参,内联函数和constexpr函数,调试帮助

重点: 1.三种函数相关的语言特性:默认实参,内联函数和constexpr函数. 2.默认实参:某些函数有一种形参,在函数的很多次调用中它们都被赋予一个相同的值. 3.一旦某个形参被赋予了默认值之后,它后面的所以形参都必须要默认值. 4.若想使用默认形参,只要在调用函数时省略该实参即可. Tip:Window = screen ( , , ‘?’ );//错误:只能省略尾部的实参! 5.对于函数的声明来说,习惯将其放在头文件当中,在给定的作用域中一个形参只能赋予一次默认实参. NOTE:通常,应

[011]默认实参

在一般的函数定义中,都是定义类似的函数. int foo(int v1, int v2); 在调用foo函数的时候,将实参传进去就可以使用foo了. 但是,我们也可以直接在函数定义的时候就给形参赋值.如: int foo(int v1 = 1, int v2 = 2); 这样定义之后,可以这样使用: foo();      ?相当于foo(1,2) foo(3); ?相当于foo(3,2) foo(3,4); ?相当于foo(3,4) 需要特别注意的是: 定义默认实参时,应该将最可能使用默认实参

C++ Primer笔记3_默认实参_类初探_名字查找与类的作用域

1.默认函数实参 在C++中,可以为参数指定默认值,C语言是不支持默认参数的,Java也不支持! 默认参数的语法与使用: (1)在函数声明或定义时,直接对参数赋值.这就是默认参数: (2)在函数调用时,省略部分或全部参数.这时可以用默认参数来代替. 注意事项: (1)函数默认值只能赋值一次,或者是在声明中,或者是在定义中,都可以. (2)默认参数定义的顺序为自右到左.即如果一个参数设定了缺省值时,其右边的参数都要有缺省值.比如int f(int a, int b=1,int c=2,int d=

C++虚函数默认实参的注意事项

我们都知道当成员函数是虚函数的时候,函数调用取决于调用函数的对象的类型而不是指针或者应用的类型.这就是C++中的多态. 那么一个虚函数的实参的缺省值是什么呢?例如如下代码: #include <iostream> #include <string> using namespace std; class A { public: virtual void func(int number = 10) { cout << "A::func() " <&

【C/C++】构造函数、默认构造函数、成员初始化列表

常见问题 Q1. 下列关于构造函数的描述中,错误的是( ) A. 构造函数可以设置默认的参数 B. 构造函数在定义类对象时自动执行 C. 构造函数可以是内联函数 D. 构造函数不可以重载 Q2. 下列代码中a.b的各个成员变量值是多少? 1 class Student 2 { 3 public: 4 Student() {} 5 void show(); 6 private: 7 string name; 8 int number; 9 int score; 10 }; 11 Student a

C++ 合成默认构造函数的真相

对于C++默认构造函数,我曾经有两点误解: 类如果没有定义任何的构造函数,那么编译器(一定会!)将为类定义一个合成的默认构造函数. 合成默认构造函数会初始化类中所有的数据成员. 第一个误解来自于我学习C++的第一本书 <C++ Primer>,在书中392页:“只有当一个类没有定义构造函数时,编译器才会自动生成一个默认构造函数”. 实际上这句话也没有说错,它说明了默认构造函数定义的必要非充分条件,然而却给当时初学C++的我造成了一定的误解. 第二个误解依旧来自于Primer中的一句话:“合成的

C++默认构造函数

C++ primer中的三个地方讲解了默认构造函数: P44变量初始化规则 P227函数(构造函数) P388类(构造函数初始化式) 一, 变量初始化规则(P44和P227) 1,对于类类型的成员,调用该成员所属类自身的默认构造函数实现初始化. 2,内置类型成员的初值依赖于对象定义的位置,如果对象在全局作用域中定义(既不在任何函数中)或定义为静态局部对象,则这些成员将被初始化为0: 3,如果对象在局部作用域中定义,则这些成员没有初始化! 二,初始化列表 由P49和P50可知:const和引用类型

函数匹配:实参类型转换

重点: 1.函数匹配的第一步是选定本次调用对应的重载函数集,集合中的函数称为候选函数. 2.候选函数具备两个特征:①是与被调用的函数同名: ②其声明在调用点可见. 3.函数匹配的第二步考察本次调用提供的实参,然后从候选函数中选出能被这组实参调用的函数,称为可行函数. 4.可行函数的两大特点:①其形参数量和被提供的实参数量相同: ②每个实参类型与形参类型相同或者是能转换成形参类型. NOTE:如果函数含有默认实参,则我们在调用函数时传入的实参数量可能会少于它实际使用的实参数量. 5.函数匹配的第三