普通引用和常引用

1. 变量名的回顾

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

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

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

问题：一段连续的内存空间是否只能有一个别名吗?

2. C++引用的概念

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

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

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

3. 引用意义

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

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

4. 引用的本质

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

Type& name çè Type* const name

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

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

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

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

#include <stdio.h>

#include <stdlib.h>

int main5_1()

{

// 定义变量 a，a 是一个整形变量，占4个字节

// a 变量代表这4个字节的内存，a就是这块内存的名字

int a = 10;

// 定义一个引用变量，b 是 a 的引用

// a 是一块4字节内存的名字，引用的意思是给这块内存重新取个名字

// b a代表的那块内存的别名，b 和 a 代表同一块内存

// 引用的语法： 在定义变量的时候在变量前加 &

int &b = a;

int c = 40;

// 这是复制操作，将c的之赋给b

// 普通引用在定义必须要初始化，引用是一块空间的别名，

// 如果空间不存在，引用就没有意义

b = c;

b = 90;

printf ("a = %d, b = %d, c = %d\n", a, ,b, c);

return 0;

}

void swap5_1(int* a, int* b)

{

int tmp = *a;

*a = *b;

*b = tmp;

}

void swap5_3(int &a, int &b)

{

int tmp = a;

a = b;

b = tmp;

}

int main5_2()

{

int a = 10;

int b = 20;

swap (a, b);

// swap (&a, &b);

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

return 0;

}

struct A

{

int id;

char name[20];

};

void init (A** p)

{

*p = (A*)malloc(sizeof(A)/sizeof(char));

}

// 指针引用

void init1 (A* &p)

{

p = (A*)malloc(sizeof(A)/sizeof(char));

p->id = 20;

}

int main5_3()

{

A* pa = NULL;

// init (&pa);

init1 (pa);

printf ("id = %d\n", pa->id);

return 0;

}

void func (A* pa)

{

printf ("id = %d, name = %s\n", pa->id, pa->name);

}

void func5_1 (A &a)

{

// 引用是空间的别名，操作结构体的时候用

printf ("id = %d, name = %s\n", a.id, a.name);

}

int main5_4()

{

A a = {10, "wang"};

// func (&a);

func5_1 (a);

return 0;

}

struct B

{

double &a;

double &b;

};

int main5_5()

{

double a = 10;

double &b = a;

printf ("size = %d\n", sizeof(b));

// 引用本质是指针，常指针

printf ("B = %d\n", sizeof(B));

return 0;

}

#include <stdio.h>

void swap5_6(int &a, int &b)

{

int temp = a;

a = b;

b = temp;

}

// ====>

#if 0

int swap5_6(int * const a, int * const b)

{

int temp = *a;

*a = *b;

*b = temp;

}

#endif

int main5_6()

{

int a = 0;

int &b = a; // 常指针：====> int * const b = &a;

b = 90; // *b = 90;

printf ("&a = %p, &b = %p\n", &a, &b); // &b ==> &(*b)

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

return 0;

}

// 函数返回值是引用，不能返回栈上的引用，可以返回静态变量和全局变量的引用

int &func5_6()

{

static int a;

a++;

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

return a;

}

int main5_7()

{

for (int i = 0; i < 10; i++)

{

func5_6();

}

// 1、函数返回值是引用，如果用引用去接，接回来的是一个 引用

int &b = func5_6();

b = 100;

func5_6();

// 2、函数返回值是引用，可以用普通变量去接，接回来的是一个 值

int c = func5_6();

printf ("c = %d\n", c);

c = 200;

func5_6();

// 3、函数返回值是引用，可以作为左值来使用

func5_6() = 200;

printf ("b = %d\n", b);

func5_6();

return 0;

}

int add(int &a, int &b)

{

return a + b;

}

int main6_1()

{

int a = 10;

int b = 20;

printf ("a + b = %d\n", add(a, b));

// printf ("a + b = %d\n", add(10, b));

// int &c = 10; // int * const c = &10;

return 0;

}

int add2(const int &a, const int &b)

{

return a + b;

}

int main6_3()

{

printf ("a + b = %d\n", add2(10,20));

return 0;

}

int main6_2()

{

// 常量 放在常量表中

const int a = 10;

int c = 10;

// 普通引用

int &b = c;

// 常引用，意思不能通过引用改变被引用的值

const int &d = c; // const int * const d = &c;

// 常引用的初始化有2中方式

// 1、引用普通变量，不能改变变量的值

{

int a1 = 100;

const int &ra = a1;

}

// 2、使用常量去初始化常引用

{

// 当使用常量对常引用进行初始化的时候，编译器会为这个常量分配一块空间

// 将这个常量的值复制到这个空间里

// 然后让这个常引用作为这个空间的别名

const int &ra = 10; // const int * const ra = &10;

// ra = 90;

int *p = (int *)&ra;

*p = 200;

printf ("ra = %d\n", ra);

}

return 0;

}