引用的基础知识（定义和函数参数）

1. 引用概念

变量是c++的概念，从内存的角度理解，其实就是指向了一段内存空间的地址。我们可以给变量创建别名，这个别名就是引用。

2. 引用的基本用法

int main()
{
    int a = 10;
    int &b = a; //普通引用必须要初始化
    cout << "b address = "<< &b  << " a address = " << &a << endl;
    cout << "b = " << b << endl;
    a = 100;
    int &c = b;
    cout << "b = " << b << endl;
    a = 101;
    cout << "c = " << c << endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

输出

b address = 0x7ff7bfeff308 a address = 0x7ff7bfeff308
b = 10
b = 100
c = 101

输出的结果看出，b和c都是变量a的引用，a变量的值发生变化后，引用对应的值也改变。
“b address = 0x7ff7bfeff308 a address = 0x7ff7bfeff308” 也可以说明引用是变量名的别名，都指向了同一块内存空间。
注意：普通的引用需要初始化 ，如果引用作为函数传参可以不用初始化。

例子：交换两个数

void swapNum01(int a, int b)
{
    int c = 0;
    c = a;
    a = b;
    b = c;
}

//指针
void swapNum02(int *a, int *b)
{
    int c = 0;
    c = *a;
    *a = *b;
    *b = c;
}

//引用
void swapNum03(int &a, int &b)
{
    int c = 0;
    c = a;
    a = b;
    b = c;
}

int main()
{
    int a = 10;
    int b = 20;
    swapNum01(a,b); //直接赋值
    cout << "a = " << a << " b = " << b << endl;
    
    swapNum02(&a, &b); // 取地址赋值
    cout << "a = " << a << " b = " << b << endl;
    
    swapNum03(a, b); // 通过引用赋值
    cout << "a = " << a << " b = " << b << endl;
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

输出

a = 10 b = 20
a = 20 b = 10
a = 10 b = 20

第一个方法输出的值表明a和b的变量值并没有交换，因为传参只是做了赋值操作，方法体内的交换只是方法参数的交换，不影响a和b变量；而第二（指针）和第三个（引用）方法都实现了变量值交换，其中通过引用的方式实现交换是最简洁的实现。

3. 复杂数据类型引用

struct和class等复杂数据类型的引用和普通数据类型的使用差不多，以下是例子：

3.1 struct

struct Teacher
{
    int age;
};

void changeAge1(Teacher t) //函数参数是类，此时相当于数据拷贝
{
    t.age = 31;
}

void changeAge2(Teacher &t) //函数参数是引用
{
    t.age = 32;
}

void changeAge3(Teacher *t) //函数参数是指针
{
    t->age = 33;
}

int main()
{
    Teacher t;
    t.age = 30;
    cout << t.age << endl;
    
    changeAge1(t);
    cout << t.age << endl;
    
    changeAge2(t);
    cout << t.age << endl;
    
    changeAge3(&t);
    cout << t.age << endl;
    
    return 0;
}
 */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

输出

30
30
32
33

3.2 class类

class Teacher
{
public:
    int age;
};

void changeAge01(Teacher t)
{
    t.age = 31;
}

void changeAge02(Teacher &t)
{
    t.age = 32;
}

void changeAge03(Teacher *t)
{
    t->age = 33;
}

int main()
{
    Teacher t;
    t.age = 30;
    cout << t.age << endl;
    
    changeAge01(t);
    cout << t.age <<endl;
    
    changeAge02(t);
    cout << t.age <<endl;
    
    changeAge03(&t);
    cout << t.age <<endl;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

结果

30
30
32
33

4. 引用的本质

引用和指针类似，引用变量在内存空间的占用是4个字节，和指针一致。
Type &a == Type* const a

4.1 间接赋值三要素

1. 创建两个变量，一个实参（a)，一个形参(b)；
2. 建立关系，实参取地址赋值给行参(b=*a)；
3. *b形参去间接修改实参的值；

int a = 0;
int *b = NULL;
b = &a; //建立关系，实参地址赋给形参
*b = 1; //通过行参间接修改实参的值
1
2
3
4

4.2 结论

因此引用是c++编译器为了简化常量指针的写法，将引用自动转化为常量指针实现，省去开发者使用指针取地址的操作。
从间接赋值三要素来看，引用是c++编译器为开发者实现了建立关系和修改实参两步，这也是为什么说引用是c++的概念。