普通引用

 

普通引用

 

1、引用的语法：Type& name = var; 

2、属于C++的语法范畴，属于C++编译器对C的扩展，不能用c语言的语法取思考

3、普通引用要初始化

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

 

复杂数据类型的引用

 

//复杂数据类型的引用
struct teacher
{
	char name[63];
	int age;
};

void printft(teacher *pt)
{
	cout << pt->age << endl;
 }

//pt是t1的别名，相当于修改了t1
void printft2(teacher &pt)
{
	cout << pt.age << endl;
	pt.age = 90;
}

//pt和t1s是两个不同的变量
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，相当于 pt=t1

	printf("t1.age:%d\n",t1.age);

	printf("pt.age:%d\n", t1.age);
	system("pause");

}

 

引用的本质探究

//引用本质探究
// 1、单独定义引用时，必须初始化，说明很像一个常量
void main04()
{
	int a = 10;
	int &b = a;//b很像一个常量
	//b是a的别名，请问c++编译器后面做了什么工作？
	b = 11;
	cout << "b--->" << a << endl;
	printf("a:%d\n", a);
	printf("b:%d\n", b);
	printf("&a:%d\n", &a);
	printf("&b:%d\n", &b);  //a、b是同一块内存空间的门牌号
	printf("sizeof(teacher):%d\n", &b);  //a、b是同一块内存空间的门牌号
	system("pause");
}

//2、普通引用有自己的内存空间吗？ //有 
struct person
{
	char name[64];//64字节
	int age;//4字节
	int &a;// 10字节  //很像指针所占内存空间大小 //换成double结果也是一样，和内存没关系  //普通引用不是要赋初值吗？
	int &b;// 10字节
	
};

void main05()
{
	printf("sizeof(person):%d\n", sizeof(person));  //a、b是同一块内存空间的门牌号
	system("pause");
}

// 3、引用本质探究
void modifya1(int &a1)
{
	 a1 = 100;
}

void modifya2(int * const a1)
{
	*a1 = 200; //*实参的地址 去间接地修改实参的值
}

void main06()
{
	int c = 10;
	//1
	modifya1(c);//指向这个函数调用的时候，不用手动取地址
	cout << "c=" << c << endl;

	//2
	c = 10;
	modifya2(&c);//如果是指针，需要程序员手动取地址
	cout << "c=" << c<< endl;

	system("pause");
}



//间接赋值
void modifya3(int *p)
{
	*p = 100;//3、*p形参间接修改实参
}

void main()
{
	int p = 10;
	int *n = NULL;//间接赋值三个条件 1、定义两个变量
	n = &p;
	*n = 100;

	modifya3(&p);//2、建立关联
	system("pause");
}

 

间接赋值成立的三个条件

1、定义两个变量 （一个实参一个形参）

2、建立关联 实参取地址传给形参

3、*p形参去间接的修改实参的值

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

 

 

 

 

引用本质的结论

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

Type& name  =  Type* const name

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

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

函数返回值是引用

C++引用使用时的难点：当函数返回值为引用时

1、若返回栈变量

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

2）不能作为左值使用

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

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

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

 

 

#include <iostream>
using namespace std;

// 一、返回栈变量
int getAA1()
{
	int a;
	a = 10;
	return a;
}

//基础类型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(); 
	//当函数返回值为引用时
	//若返回栈变量
	//不能成为其它引用的初始值
	//不能作为左值使用

	cout << "a1=" << a1 << endl;
	cout << "a2=" << a2 << endl;
	cout << "a3=" << a3 << endl; //c++编译器发现返回的是引用，会帮我们做这么一个操作 *a3
	system("pause");
}



// 二、变量是static或者是全局变量
int j()
{
	static int a = 10;
	a++;
	return a;

}

int& j1()
{
	static int a = 10;
	a++;
	return a;
}

int *j2()
{
	static int a = 10;
	a++;
	return &a;
}

void main02()
{
	int a1 = 0;
	int a2 = 0;
	a1 = j();
	a2 = j1();
	int &a3 = j1();
	cout << "a1=" << a1 << endl;
	cout << "a2=" << a2 << endl;
	cout << "a3=" << a3 << endl;
	system("pause");
}
//若返回静态变量或全局变量
//可以成为其他引用的初始值
//即可作为右值使用，也可作为左值使用


//
//——函数当左值

//返回变量的值
int g1()
{
	static int a = 10;
	a++;
	return a;

}

//返回变量本身
int& g2()
{
	static int a = 10;
	a++;
	printf("a=%d\n",a);
	return a;
}


void main()
{
	//g1() = 100;// 错误
	g2() = 100;//函数返回值是引用，并且当左值
	g2();
	int c1 = g1();//函数返回值是引用，并且当右值
	int c2 = g2();//函数返回值是引用，并且当右值
	system("pause");
}