默认参数函数,引用

一:默认参数函数

#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
void test(int sum = 0) //函数的定义
{
    cout<<"默认参数sum="<<sum<<endl;
}
void test1(int c = 0)
{
    cout<<"默认参数c="<<c<<endl;
}
void test2(int x = 0,int y = 1,int b = 0)
{
    cout<<"使用默认参数时要从右至左逐次定义"<<endl;
}
//void test3(int x = 1,int y,int b = 0) //未从右至左逐次定义 中间有一个没有使用默认参数
void test4(int x,float y = 0,int b = 0)
{
    cout<<"从右至左逐次定义"<<endl;
}
int main(int argc, char** argv)
{

    void test1(int c = 0);
    test1();
    test();
    test2();
    test4(4); //在调用函数时,传入的参数是从左至右匹配的,其中未指定默认值的参数必须传入实际值。
    return 0;
}

二:引用基本概念:

(1):语法格式:类型标识符&引用名=目标变量名。

(2):类型标识符是指目标变量的类型。

(3):声明引用时,必须同时对其进行初始化,即给出引用的具体变量。

(4): 声明引用完毕后,相当于目标变量有两个名称,即该目标原名称和引用名。

(5):声明一个引用不是新定义了一个变量,它只表示该引用名是目标变量名的一个别名,所以,系统并不给引用分配存储单元.

 1 #include <iostream>
 2 using namespace std;
 3 /* run this program using the console pauser or add your own getch, system("pause") or input loop */
 4 void test(int &r)
 5 {
 6     cout<<"通过修改引用作为参数的形参可以修改到实参"<<endl;
 7     r = 10;
 8  }
 9
10 int main(int argc, char** argv)
11 {
12     int f = 8;
13     int &r = f; //引用一个变量
14     cout<<"r="<<"f="<<r<<"="<<f<<endl;
15
16     r = 2; //记住引用是不具备内存空间的,so此时修改的是f;
17     cout<<f<<endl; //2
18
19     int c = 0;
20     r = c;
21     cout<<"引用c后的r="<<r<<"f="<<f<<endl; //输出:引用c后的r=0f=0。
22     /*【注意】:不管你怎么使用记住他只是被引用的变量的一个别名,他什么都没有,但是通过他可以间接的来修改他所引用的变量,
23     不能与指针的定义混淆.
24     */
25
26 //引用作为函数的参数.
27      int s = 100;
28      test(s);
29      cout<<"修改引用形参来修改被引用的实参s"<<s<<endl;//s = 10;
30
31     return 0;
32 }

三:用指针来做形式参数。

 1 #include <iostream>
 2 using namespace std;
 3 /* run this program using the console pauser or add your own getch, system("pause") or input loop */
 4
 5 int test(int *p) //p是指向实参的指针变量,是具备内存空间的。
 6  {
 7      *p = 10;
 8      return 0;
 9   }
10
11 int test1(int (*c)[10] )
12 {
13     cout<<*c<<endl;
14 }
15 int main(int argc, char** argv)
16 {
17     int f = 100;
18     cout<<"输出实参未改变前的地址。判断修改前和修改后地址是否相同,"<<&f<<endl; //输出实参未改变前的地址。判断修改前和修改后地址是否相同,0x6ffe1c
19     test(&f); //传入的是f的地址
20     cout<<f<<endl; //10
21     cout<<"输出改变值后的地址"<<&f<<endl; //输出改变值后的地址0x6ffe1c
22
23
24 //我们知道函数是不能返回数组的,所以我们通过指针来实现返回数组
25      int s[10] = {1,2,3,4,5,6,7,8,9,10};
26      int *c = test1(&s);
27      cout<<*c<<endl;
28     return 0;
29 }

原文地址:https://www.cnblogs.com/1314bjwg/p/12386854.html

时间: 2024-07-29 15:21:01

默认参数函数,引用的相关文章

&lt;C++&gt; 函数默认参数 函数重载 引用

一.函数默认参数 1.缺省参数:就是在声明函数的某个参数的时候 给他一个默认值 1 #include<iostream> 2 using namespace std; 3 4 void Show(int a = 1,int b = 2,int c = 3) 5 { 6 cout << a << endl; 7 cout << b << endl; 8 cout << c << endl; 9 } 10 11 int mai

C/C++(C++重载,默认参数,引用)

C++重载详解 重载就是同名而非同义,具体意义根据上下文的语境而言. 重载规则: 1,函数名相同. 2,参数个数不同,参数的类型不同,参数顺序不同,均可构成重载. 3,返回值类型不同则不可以构成重载. 函数重载(静多态) void print(int a) { //... } void print(int a,char b) { //... } void print(char a,int a) { //... } //根据参数的数序,个数执行上下文. 匹配原则: 1,严格匹配,找到则调用. 2,

C++基础 inline 默认参数 函数占位参数

1. inline内联函数 内联函数用于替换宏, 实例: 其中宏和 ++ 连用有副作用. #include "iostream" using namespace std; #define MYFUNC(a, b) ((a) < (b) ? (a) : (b)) inline int myfunc(int a, int b) { return a < b ? a : b; } int main() { int a = 1; int b = 3; //int c = myfun

重载函数和默认参数的函数

代码说事 重载的参数匹配 1 /// *重载的匹配顺序 1: 严格匹配 2: 转换匹配 2 /// *重申 : 重载的判断依据 !形参的! 个数 类型 位置 3 /// * 返回值类型不作为重载依据 4 /// * 默认参数 不能用于区分重载函数 5 6 #include <bits/stdc++.h> 7 using namespace std; 8 9 /// 转换 的匹配 10 double b; 11 void print(int a); 12 void print(char c);

函数重载和默认参数

区别一是参数类型不同,二是参数个数不同 仅有函数返回值不同也是区分不了重载函数的 1 #include <iostream> 2 using namespace std; 3 4 void go(int i, double db)//参数的个数,参数的类型不同,顺序不同,与返回值无关 5 { 6 7 } 8 9 void go(double db, int i) 10 { 11 12 } 13 14 void main() 15 { 16 17 system("pause"

【C/C++学院】0813-C与CPP不同以及命名空间简介/函数重载与函数默认参数/泛型auto/Newdelete

C与CPP不同以及命名空间简介 命名空间在软件设计中的作用就是为了实现迭代式开发. 命名空间的别名 #include <iostream> namespace runrunrunrun { int a(10); char *str("gogogo"); namespace run //命名空间的嵌套 { int a(9); } } namespace runrunrunrun //命名空间的拓展 { int y(5); //int a(15);重定义错误 } namespa

Python:默认参数

Python是个人最喜欢的语言,刚开始接触Python时,总觉得有很多槽点,不太喜欢.后来,不知不觉中,就用的多了.习惯了.喜欢上了.Python的功能真的很强大,自己当初学习这门语言的时候,也记录过很多的笔记,现慢慢把这些笔记发布出来,希望对大家有所帮助,对自己也算是一个总结. 关于Python默认参数,假如默认参数是可变对象是会有副作用的,这一点我一开始不是很理解,直到有一天,看到一篇博文说:一个函数参数的默认值,仅仅在该函数定义的时候,被赋值一次.如此,只有当函数第一次被定义的时候,才讲参

拷贝构造,深度拷贝,关于delete和default相关的操作,explicit,类赋初值,构造函数和析构函数,成员函数和内联函数,关于内存存储,默认参数,静态函数和普通函数,const函数,友元

 1.拷贝构造 //拷贝构造的规则,有两种方式实现初始化. //1.一个是通过在后面:a(x),b(y)的方式实现初始化. //2.第二种初始化的方式是直接在构造方法里面实现初始化. 案例如下: #include<iostream> //如果声明已经定义,边不会生成 class classA { private: int a; int b; public: //拷贝构造的规则,有两种方式实现初始化 //1.一个是通过在后面:a(x),b(y)的方式实现初始化 //2.第二种初始化的方式是直

【转】深入理解C++的动态绑定和静态绑定 &amp; 不要重定义虚函数中的默认参数

为了支持c++的多态性,才用了动态绑定和静态绑定.理解他们的区别有助于更好的理解多态性,以及在编程的过程中避免犯错误.需要理解四个名词:1.对象的静态类型:对象在声明时采用的类型.是在编译期确定的.2.对象的动态类型:目前所指对象的类型.是在运行期决定的.对象的动态类型可以更改,但是静态类型无法更改.关于对象的静态类型和动态类型,看一个示例: class B { } class C : public B { } class D : public B { } D* pD = new D();//p