普通引用和常引用

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;
}