c++引用详解

铺垫:

变量名实质上是一段连续存储空间的别名,是一个标号

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

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

(能不能再名字的基础上在起个名字?)

概念:

1) 可以看做一个已定义变量的别名

引用是c++的语法范畴,不能再用C语言的思想去思考问题(间接修改)

属于c++编译器对c的扩展

引用做函数参数

普通引用在声明时必须用其他的变量进行初始化

引用作为函数参数声明时不进行初始化

#include<IOStream>
using namespace std;
//引用基本用法
void mAIn()
{
	
	int a = 10;
	int &b = a;
	b = 100;
	printf("b:%dn", b);
	printf("a:%dn", a);
	cout << "hello...." << endl;
	system("pause");
	return;
}
void main11()
{
	int a = 10;
	int &b = a;
	//int &c;  //普通引用必须要初始化
	system("pause");
}
void myswap01(int a, int b)
{
	int c = 0;
	c = a;
	a = b;
	b = c;
}
void myswap02(int *a,int *b)
{
	int c = 0;
	c = *a;
	*a = *b;
	*b = c;
}
void myswap03(int &a, int &b)
{
	int c = 0;
	c = a;
	a = b;
	b = c;
}
void  main()
{
	int x, y;
	x = 10;
	y = 20;
	myswap01(x, y);
	printf("x:%d,y:%dn", x, y);
	myswap02(&x, &y);
	printf("x:%d,y:%dn", x, y);
	myswap03(x, y);
	printf("x:%d,y:%dn", x, y);
	system("pause");
}
//复杂数据类型 的引用
struct 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和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的别名
  printfT3(t1);//pT是形参,t1拷贝了一份数据,给pT
  printf("t1.age:%dn",t1.age);
	cout << "hello...." << endl;
	system("pause");
	return;
}

引用的意义

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

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

引用的本质

c++编译器背后做了什么工作

单独定义的时候必须初始化--->很像常量

1)引用在c++内部实现是一个常指针

2)c++编译器在编译过程中使用常指针作为引用的内部实现,因此引用所占的空间与指针相同

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

结论:当我们使用引用的语法时,我们不用去关心编译器引用是怎么做了

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

#include<iostream>
using namespace std;
void main01()
{
	const int c1 = 10;
	int a = 10;
	int &b = a;//像常量
	printf("&a:%dn", &a);
	printf("&b:%dn", &b);//a b就是同一块内存空间的门牌号   依附于这个内存空间
	cout << "hello.." << endl;
	system("pause");
	return;
}
//普通引用有自己的空间吗?-->有,和指针所占的一样
struct Teacher
{
	char name[64];//64
	int age;//4
	int &a;//4
	int &b;//4
};
//引用的本质一个常量指针
void main()
{
	printf("sizeof(Teacher):%dn", sizeof(Teacher);
	system("pause");
}

void  modifyA(int &a1)
{
	a1 = 100;
}
void  modifyA2(int* const a1)
{
	*a1 = 10;//*实参的地址,去间接修改实参的值
}
void main()
{
	int a = 10;
	modifyA(a);//指向这个函数调用的时候,我们程序员不需要取a的地址
	printf("a:%dn", a);

	modifyA2(&a);//如果是指针 需要我们手工去取实参地址
	printf("sizeof(Teacher):%dn", sizeof(Teacher));
	system("pause");
}

//间接赋值
//间接赋值成立的三个条件
/*
1 定义2个变量
2 建立关系  实参取地址传给形参
3 形参间接修改实参的值
*/
void  modifyA3(int *p)
{
	*p = 190;//3
}
void main()
{
	int a = 10;
	int *p = NULL; //1
	p = &a;
	*p = 100;
	{
		*p = 200;
	}
	modifyA3(&a);//2
}
//引用是间接赋值哪几个条件的组合?     2编译器做了
//1   23后2个条件写在一起了         只不过2编译器做了

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

c++引用使用时的难点:

当函数返回值为引用时,

若返回栈变量,不能成为其他引用的初始值,不能作为左值使用

若返回静态变量或全局变量 可以成为其他引用的初始值.

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

#include<iostream>
using namespace std;
int getAA1()
{
	int a;
	a = 10;
	return a;
}
//返回a的本身
int& getAA2()
{
	int a;
	a = 10;
	return a;
}
int* getAA3()
{
	int a;
	a = 10;
	return &a;
}

void main01()
{
	int a1 = 0;
	int a2 = 0;
	a1 = getAA1();
	a2 = getAA2();
	int &a3= getAA2();
	printf("a1:%dn", a1);
	printf("a2:%dn", a2);
	printf("a3:%dn", a3);
	cout << "hello.." << endl;
	system("pause");
	return;
}
//返回静态/全局
int j()
{
	static int a = 10;
	a++;
	return a;
}
int &j()
{
	static int a = 10;
	a++;
	return a;

}
void main()
{
	int a1 = 10;
	int a2 = 20;
	a1 = j1();
	a2 = j2();
	int &a3 = j2();
	printf("a1:%dn", a1);
	printf("a2:%dn", a2);
	printf("a3:%dn", a3);
	cout << "hello.." << endl;
	system("pause");
	return;

}
//函数当左值 
//返回变量的值
int g()
{
	static int a = 10;
	a++;
	return a;
}
//返回变量本身
int &g()
{
	static int a = 10;
	a++;
	return a;
}
void main()
{
	//g1() = 100;//执行这个,函数返回值就是11.不成立err
	g2() = 100;//把上面的函数改成了100,所以这个就成立

	system("pause");
}

指针的引用

#include<iostream>
using namespace std;
struct Teacher
{
	char name[64];
	int age;

};
int getTeacher(Teacher **p)
{
	Teacher *tmp = NULL;
	if (p == NULL)
	{
		return -1;
	}
	tmp = (Teacher*)malloc(sizeof(Teacher));
	if (tmp == NULL)
	{
		return -2;
	}
	p->age = 33;
	*p = tmp;
}
//指针的引用做函数参数
int getTeacher2(Teacher* &myp)
{//给myp赋值相当于给主函数中的pT1赋值
	myp = (Teacher*)malloc(sizeof(Teacher));
	if (myp == NULL)
	{
		return -1;
	}
	p->age = 36;
}
void FreeTeacher(Teacher *pT1)
{
	if (pT1 == NULL)
	{
		return;
	}
	free(pT1);
}
void main()
{
	Teacher *pT1 = NULL;
	getTeacher(&pT1);//二级指针
	cout << "age:" << pT1->age << endl;
	FreeTeacher(pT1);

	getTeacher2(pT1);//引用
	cout << "age:" << pT1->age << endl;
	FreeTeacher(pT1);
	cout << "hello.." << endl;
	system("pause");
	return;
}

c++中的const常量

可能分配内存空间,也可能不分配

当const常量为全局,并且需要在其他文件中使用,会分配空间

在使用&操作符,取const常量的地址,会分配

当const修饰引用,会分配

#include<iostream>
using namespace std;

void main()
{
	int x = 20;
	const int &y = x;//常引用  让变量拥有只读属性 不同通过y去修改x了
	//常引用初始化分为2种情况//1)用变量 初始化 常引用
	{
		int x1 = 30;
		const int &y1 = x1;
	
	}
	//2)用字面量 初始化 常引用
	{
		const int a = 40;
		int &m = 41;//普通引用 引用一个字面量
		//字面量有没有内存地址?-->没有

	}
	cout << "hello.." << endl;
	system("pause");
	return;
}

结论:

const &int e==const int* const e

普通引用==int const e

当使用常量对const引用进行初始化时,编译器会为常量值分配空间,并用引用名作为这段空间的别名

使用字面量对const引用初始化后,将生成一个只读变量