2020-09-22C++学习笔记之引用1（1.引用（普通引用）2.引用做函数参数 3.引用的意义 4.引用本质5.引用结论 6.函数返回值是引用(引用当左值)7测试代码）

2020-09-22C++学习笔记之引用1（1.引用（普通引用）2.引用做函数参数 3.引用的意义 4.引用本质5.引用结论 6.函数返回值是引用(引用当左值)7测试代码）

1.引用（普通引用）

变量名回顾

变量名实质上是一段连续存储空间的别名，是一个标号(门牌号)

程序中通过变量来申请并命名内存空间

通过变量的名字可以使用存储空间

1.2引用概念

a) 在C++中新增加了引用的概念

b) 引用可以看作一个已定义变量的别名

c) 引用的语法：Type& name = var;

d） 引用做函数参数那？（引用作为函数参数声明时不进行初始化）

void main01()
{
	int a = 10; //c编译器分配4个字节内存。。。a内存空间的别名
	int &b = a;  //b就是a的别名。。。
	a =11; //直接赋值
	{
		int *p = &a;
		*p = 12;
		printf("a %d \n",a);
	}
	b  = 14; 
	printf("a:%d b:%d", a, b);
	system("pause");
}

2.引用做函数参数

truct Teacher
{
	char name[64];
	int age ;
};

void printfT(Teacher *pT)
{
	cout<<pT->age<<endl;
}

//pT是t1的别名 ,相当于修改了t1
void printfT2(Teacher &pT)
{
	//cout<<pT.age<<endl;
	pT.age = 33;
}

//pT和t1的是两个不同的变量
void printfT3(Teacher pT)
{
	cout<<pT.age<<endl;
	pT.age = 45; //只会修改pT变量 ,不会修改t1变量
}
void main()
{
	Teacher t1;
	t1.age = 35;

	printfT(&t1);

	printfT2(t1); //pT是t1的别名
	printf("t1.age:%d \n", t1.age); //33

	printfT3(t1) ;// pT是形参 ,t1 copy一份数据 给pT     //---> pT = t1
	printf("t1.age:%d \n", t1.age); //35
	
	cout<<"hello..."<<endl;    
	system("pause");
	return ;
}

3.引用的意义

1）引用作为其它变量的别名而存在，因此在一些场合可以代替指针

2）引用相对于指针来说具有更好的可读性和实用性

比如：用函数来实现两个数互换

void huhuan_yinyong(int &a,int &b)//引用作为函数参数声明时不进行初始化
{
	int c;

	c=a;
	a=b;
	b=c;

	cout<<"a="<<a<<endl;
	cout<<"b="<<b<<endl;
}
//指针与引用对比（相对于上面函数）
void huhuan_zhizhen(int * a,int *b)
{
	int c;

	c=*a;
	*a=*b;
	*b=c;

	cout<<"a="<<*a<<endl;
	cout<<"b="<<*b<<endl;
}

4.引用本质

1）引用在C++中的内部实现是一个常指针

Type& name çèType* const name

2）C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。

3）从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间。这是C++为了实用性而做出的细节隐藏

5.引用结论

）引用在实现上，只不过是把：间接赋值成立的三个条件的后两步和二为一

//当实参传给形参引用的时候，只不过是c++编译器帮我们程序员手工取了一个实参地址，传给了形参引用（常量指针）

2）当我们使用引用语法的时，我们不去关心编译器引用是怎么做的

当我们分析奇怪的语法现象的时，我们才去考虑c++编译器是怎么做的

6.函数返回值是引用(引用当左值)

C++引用使用时的难点：

当函数返回值为引用时

若返回栈变量

不能成为其它引用的初始值

不能作为左值使用

若返回静态变量或全局变量

可以成为其他引用的初始值

即可作为右值使用，也可作为左值使用

//正确
int & zuozhiyinyong()
{
	static int a = 10;
	a ++;
	printf("a:%d \n", a);
	return a;

}
int * zuozhiyinyong1()
{
	static int b = 20;
	b++;
	printf("b:%d \n", b);
	return &b;
}

//错误，不能做左值使用，就是错误
int & zuozhiyinyong()
{
	int a = 10;
	a ++;
	printf("a:%d \n", a);
	return a;

}
int * zuozhiyinyong1()
{
	int b = 20;
	b++;
	printf("b:%d \n", b);
	return &b;
}

7测试代码

#include <iostream>
#include <string>
using namespace std;
/* a)	在C++中新增加了引用的概念
 * b)	引用可以看作一个已定义变量的别名
 * c)	引用的语法：Type& name = var; 
 * d） 引用做函数参数那？（引用作为函数参数声明时不进行初始化）
*/

void huhuan_yinyong(int &a,int &b)//引用作为函数参数声明时不进行初始化
{
	int c;

	c=a;
	a=b;
	b=c;

	cout<<"a="<<a<<endl;
	cout<<"b="<<b<<endl;
}
//指针与引用对比（相对于上面函数）
void huhuan_zhizhen(int * a,int *b)
{
	int c;

	c=*a;
	*a=*b;
	*b=c;

	cout<<"a="<<*a<<endl;
	cout<<"b="<<*b<<endl;
}
//结构体引用
struct student
{
	string name;
	int age;
};

void students(student &student1)
{
	cout<<"student1.name:"<<student1.name<<endl;
	cout<<"student1.age:"<<student1.age<<endl;
}
/*下面两函数本质是一样的，C++编译器帮我们引用打造好了指针，其实本质一样
 * 
*/
int & zuozhiyinyong()
{
	static int a = 10;
	a ++;
	printf("a:%d \n", a);
	return a;

}
int * zuozhiyinyong1()
{
	static int b = 20;
	b++;
	printf("b:%d \n", b);
	return &b;

}
int& getAA1()
{
	int a;
	a = 10;
	return a;
}

int* getAA2()
{
	int a;
	a = 10;
	return &a;
}

/* 1）引用在C++中的内部实现是一个常指针
 * Type& name Type* const namespace
 * 2）C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。
 * 3）从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间。这是C++为了实用性而做出的细节隐藏
*/
int main(int argc,char const *argv[])
{
	int a=10,c=20;

	int &b=a;//普通引用在声明时必须用其它的变量进行初始化，否则会出错 //b就是a的别名 //引用是C++的概念
			//int * const b = &a 

	int *p=&a;

	student xiaoming{
	"xiaoming",
		10
	};
	
	huhuan_yinyong(a,c);
	huhuan_zhizhen(&a,&c);
	students(xiaoming);
	b=11;//*b = 11;
	printf("a=%d,b=%d,*p=%d\n",a,b,*p);
	cout<<"sizeof(students)"<<sizeof(student)<<endl;

	zuozhiyinyong()=100;
	*zuozhiyinyong1()=200;
	zuozhiyinyong();
	*zuozhiyinyong1();

	a=getAA1();//这里g++ 7.5版本编译出警告，执行会有提示，vs2013会通过
	a=*getAA2();
	return 0;
}