C++ 引用

C++引用

一、引用的基本的概念

引用 是 C++ 相对于C语言的一个扩充。引用可以看做是数据的一个别名，通过这个别名和原来的名字都能够找到这份数据。引用类似于 Windows 中的快捷方式，一个可执行程序可以有多个快捷方式，通过这些快捷方式和可执行程序本身都能够运行程序。

---

二、引用的定义方式

type &name = data;

type 是被引用的数据的类型，name 是引用的名称，data 是被引用的数据。引用必须在定义的同时初始化，并且以后也要从一而终，不能再引用其它数据，这有点类似于常量（const 变量）。

---

三、引用作为函数的参数

    #include <iostream>
    using namespace std;
    void swap1(int a, int b);
    void swap2(int *p1, int *p2);
    void swap3(int &a, int &b);
    int main(){
        int num1, num2;
        cout<<"Input two integers: ";
        cin>>num1>>num2;
        swap1(num1, num2);
        cout<<num1<<" "<<num2<<endl;
       
        cout<<"Input two integers: ";
        cin>>num1>>num2;
        swap2(&num1, &num2);
        cout<<num1<<" "<<num2<<endl;
       
        cout<<"Input two integers: ";
        cin>>num1>>num2;
        swap3(num1, num2);
        cout<<num1<<" "<<num2<<endl;
        return 0;
    }
    //直接传递参数内容
    void swap1(int a, int b){
        int temp = a;
        a = b;
        b = temp;
    }
    //传递指针
    void swap2(int *p1, int *p2){
        int temp = *p1;
        *p1 = *p2;
        *p2 = temp;
    }
    //按引用传参
    void swap3(int &a, int &b){
        int temp = a;
        a = b;
        b = temp;
    } 

---

1. swap1() 直接传递参数的内容，不能达到交换两个数的值的目的。对于 swap1() 来说，a、b 是形参，是作用范围仅限于函数内部的局部变量，它们有自己独立的内存，和 num1、num2 指代的数据不一样。调用函数时分别将 num1、num2 的值传递给 a、b，此后 num1、num2 和 a、b 再无任何关系，在 swap1() 内部修改 a、b 的值不会影响函数外部的 num1、num2，更不会改变 num1、num2 的值。

2. swap2() 传递的是指针，能够达到交换两个数的值的目的。调用函数时，分别将 num1、num2 的指针传递给 p1、p2，此后 p1、p2 指向 a、b 所代表的数据，在函数内部可以通过指针间接地修改 a、b 的值。我们在《C语言指针变量作为函数参数》中也对比过第 1)、2) 中方式的区别。

3. swap3() 是按引用传递，能够达到交换两个数的值的目的。调用函数时，分别将 a、b 绑定到 num1、num2 所指代的数据，此后 a 和 num1、b 和 num2 就都代表同一份数据了，通过 a 修改数据后会影响 num1，通过 b 修改数据后也会影响 num2。

---

四、引用作为返回值

    #include <iostream>
    using namespace std;
    int &plus10(int &n){
        n = n + 10;
        return n;
    }
    int main(){
        int num1 = 10;
        int num2 = plus10(num1);
        cout<<num1<<" "<<num2<<endl;
        return 0;
    }

---

五、引用的本质和指针的区别

    #include <iostream>
    #include <iomanip>
    using namespace std;
    int num = 99;
    class A{
    public:
        A();
    private:
        int n;
        int &r;
    };
    A::A(): n(0), r(num){}
    int main (){
        A *a = new A();
        cout<<sizeof(A)<<endl;  //输出A类型的大小
        cout<<hex<<showbase<<*((int*)a + 1)<<endl;  //输出r的内容
        cout<<&num<<endl;  //输出num变量的地址
        return 0;
    }
    结果：
    8
	0x442000
	0x442000

从以上的的代码中，从运行结果可以看出：

成员变量 r 是占用内存的，如果不占用的话，sizeof(A)的结果应该为 4。
r 存储的内容是0x442000，也即变量 num 的地址。

这说明 r 的实现和指针非常类似。如果将 r 定义为int *类型的指针，并在构造函数中让它指向 num，那么 r 占用的内存也是 4 个字节，存储的内容也是 num 的地址。

其实引用只是对指针进行了简单的封装，它的底层依然是通过指针实现的，引用占用的内存和指针占用的内存长度一样，在 32 位环境下是 4 个字节，在 64 位环境下是 8 个字节，之所以不能获取引用的地址，是因为编译器进行了内部转换。

    int a = 99;
    int &r = a;
    r = 18;
    cout<<&r<<endl;

会被转化为以下的形式：

    int a = 99;
    int *r = &a;
    *r = 18;
    cout<<r<<endl;

使用&r取地址时，编译器会对代码进行隐式的转换，使得代码输出的是 r 的内容（a 的地址），而不是 r 的地址，这就是为什么获取不到引用变量的地址的原因。也就是说，不是变量 r 不占用内存，而是编译器不让获取它的地址。