C++（9）普通引用

变量名

变量名实质上是一段连续存储空间的别名，是一个标号(门牌号)
程序中通过变量来申请并命名内存空间
通过变量的名字可以使用存储空间

引用

引用可以看作一个已定义变量的别名
引用的语法：Type& name = var;

include <stdio.h>
 
int main()
{
    // 定义一个int型变量a,在内存中占4个字节，
    // 变量名 a 就代表了这一块内存，或者说 a 是这块内存的别名
    int a = 10;
 
    // 定义了一个引用变量 b ，它是 a 的别名，和 a 代表同一块内存空间
    // 对 b 的操作 和 对 a 的操作是一样的
    int& b = a;
 
    // 改变 b 等于改变了 a
    b = 20;
 
    printf ("%d, %d\n", a, b);
 
    // a 与 b 代表同一块内存空间
    printf ("%p, %p\n", &a, &b);
 
    return 0;
}


执行结果：
a = 20
b = 20
&a = 00CFFCA0,&b = 00CFFCA0

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

引用的意义

1）引用作为其它变量的别名而存在，因此在一些场合可以代替指针
2）引用相对于指针来说具有更好的可读性和实用性

#include <stdio.h>
 
void swap1 (int &a, int &b)
{
    int tmp = a;
    a = b;
    b = tmp;
}
 
void swap2 (int *a, int *b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}
 
int main()
{
    int a = 10;
    int b = 20;
 
    swap2 (&a, &b);
    printf ("%d, %d\n", a, b);
    swap1 (a, b);
    printf ("%d, %d\n", a, b);
 
    return 0;
}


执行结果：
a = 20,b = 10
a = 10,b = 20

复杂性数据传递

#include <stdio.h>
 
struct Student
{
    char name[20];
    int age;
};
 
void printS1(Student *pS)
{
    printf ("%s\n", pS->name);
}
 
// 复杂数据类型的引用
void printS2(Student &pS)
{
    printf ("%s\n", pS.name);
    pS.age = 80;
}
 
void printS3(Student pS)
{
    printf ("%s\n", pS.name);
}
 
int main()
{
    Student stu = {"xiaoming", 2};
 
    printS1(&stu);  // 地址传递，pS 是 变量 stu 的指针，引用成员要用 ->
 
    printS2(stu);   // pS 是 stu 的别名，和 stu 代表的是同一块内存空间,使用成员和 stu 一样 用.
    printf ("%d\n", stu.age);
 
    printS3(stu);   // 值传递，pS 是 stu 的一份复制
 
    return 0;
}

探讨：引用类型是否占据空间

#include <stdio.h>
 
struct Student
{
    char &a;
    char &b;
};
 
int main()
{
    printf ("size = %d\n", sizeof(Student));
    return 0;
}

执行结果：
	size = 8

引用的本质

引用在C++中的内部实现是一个常指针
Type& name ====> Type* const name

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

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

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

案例程序：
#include <stdio.h>
 
int main()
{
    int a = 10;
    int &b = a;  // int * const b = &a;
 
    // *b = 20;
    b = 20;
 
    // printf ("%p, %p\n", &a, &(*b));
    printf ("%p, %p\n", &a, &b);
 
    return 0;
} 

函数返回值为引用

// 不能返回一个局部变量的引用，问题在于函数运行结束后，栈空间会被释放
int & test3_1()
{
	int a = 10;
	return a;
}

int &test3_2()
{
	static int a = 10;
	a++;

	printf ("a = %d\n", a);
	return a;
}

int main3_2()
{
	int &b = test3_1();   // int *const b = test3_1();  ==>  int *const b = &a;
	cout << "b = " << b << endl;

	int &c = test3_2();
	c = 90;
	test3_2();

	// 如果一个函数返回的是引用，则改函数可以作为左值使用
	test3_2() = 200;
	test3_2();

	// 用一个普通变量去接一个 引用  接回来的是个值
	int d = test3_2();
	d = 300;
	test3_2();

	return 0;
}


执行结果：
b = 10
a = 11
a = 91
a = 92
a = 201
a = 202
a = 203

指针引用

void init(Teacher *p)
{
	p = (Teacher *)malloc(sizeof(Teacher)/sizeof(char));
	if (p == NULL)
	{
		return;
	}
	p->age = 10;
	strcpy(p->name, "小明");
}

void init1(Teacher **p)
{
	*p = (Teacher *)malloc(sizeof(Teacher)/sizeof(char));
	if (*p == NULL)
	{
		return;
	}
	(*p)->age = 10;
	strcpy((*p)->name, "小明");
}

void init2(Teacher* &p)
{
	p = (Teacher *)malloc(sizeof(Teacher)/sizeof(char));
	if (p == NULL)
	{
		return;
	}
	p->age = 10;
	p->name = (char *)malloc(sizeof(char)*100);
	strcpy(p->name, "小明");
}

// 指针引用
int main()
{
	Teacher *pt = NULL;
	// init(&pt);
	// init1(&pt);
	init2(pt);
	printf ("age = %d, name = %s\n", pt->age, pt->name);

	return 0;
}


执行结果：
age = 10, name = 小明
请按任意键继续. . .