第5课 引用的本质分析

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

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

swap函数的实现对比如下：

注意：

　　函数中的引用形参不需要进行初始化。

示例程序如下：

形参没有初始化，而是在第15行调用的时候对引用形参进行初始化。

 const引用：

当使用常量对const引用进行初始化时，C++编译器会为常量值分配空间，并将引用名作为这段空间的别名。

例：

结论：

　　使用常量对const引用初始化后将生成一个只读变量。普通引用不能使用常量值进行初始化，但是const引用可以。

我们不能直接改变const引用的值，但是可以通过取地址的方式间接的改变这块内存的值。

示例程序：

#include <stdio.h>

void Example()
{
    printf("Example:
");
    
    int a = 4;
    const int& b = a;
    int* p = (int*)&b;
    
    //b = 5;
    
    *p = 5;
    
    printf("a = %d
", a);
    printf("b = %d
", b);
}

void Demo()
{
    printf("Demo:
");
    
    const int& c = 1;
    int* p = (int*)&c;
    
    //c = 5;
    
    *p = 5;
    
    printf("c = %d
", c);
}

int main(int argc, char *argv[])
{
    Example();
    
    printf("
");
    
    Demo();

    return 0;
}

运行结果如下：

　　可以看到Example函数中通过指针p可以改变内存空间的值，最终影响到了a和b的值，其实它们指的是同一块内存空间，在这个函数中我们也可以直接改变a的值。因为a并不是const的。

 引用有自己的存储空间吗？

示例程序如下：

#include <stdio.h>

struct TRef
{
    char& r;
};

int main(int argc, char *argv[])
{ 
    char c = 'c';
    char& rc = c;
    TRef ref = { c };
    
    printf("sizeof(char&) = %d
", sizeof(char&));
    printf("sizeof(rc) = %d
", sizeof(rc));
    
    printf("sizeof(TRef) = %d
", sizeof(TRef));
    printf("sizeof(ref.r) = %d
", sizeof(ref.r));

    return 0;
}

执行结果：

char&代表char的引用，所以占用一个字节，rc也是char的引用，占用一个字节，ref.r是char的引用，也占用一个字节。

sizeof(TRef)占用四个字节，这让我们联想到了指针。

引用的内部实现：引用在C++中的内部实现是一个指针常量，具体如下。

 引用的存储空间：

示例程序：

#include <stdio.h>

struct TRef
{
    char* before;
    char& ref;
    char* after;
};

int main(int argc, char* argv[])
{
    char a = 'a';
    char& b = a;
    char c = 'c';

    TRef r = {&a, b, &c};

    printf("sizeof(r) = %d
", sizeof(r));
    printf("sizeof(r.before) = %d
", sizeof(r.before));
    printf("sizeof(r.after) = %d
", sizeof(r.after));
    printf("&r.before = %p
", &r.before);
    printf("&r.after = %p
", &r.after);

    return 0;
}

执行结果如下：

根据计算，可以得到结构体中的ref占用了4个字节。从地址的判断也可以得出ref占用了4个字节。

 上述程序在windows下的反汇编如下：

引用的意义：

函数返回引用示例程序如下：

#include <stdio.h>

int& demo()
{
    int d = 0;
    
    printf("demo: d = %d
", d);
    
    return d;
}

int& func()
{
    static int s = 0;
    
    printf("func: s = %d
", s);
    
    return s;
}

int main(int argc, char* argv[])
{
    int& rd = demo();
    int& rs = func();
    
    printf("
");
    printf("main: rd = %d
", rd);
    printf("main: rs = %d
", rs);
    printf("
");
    
    rd = 10;
    rs = 11;
    
    demo();
    func();
    
    printf("
");
    printf("main: rd = %d
", rd);
    printf("main: rs = %d
", rs);
    printf("
");
    
    return 0;
}

　　demo函数中相当于返回了局部变量的“指针”，这是有问题的。返回局部变量的引用是要禁止的。func函数中返回的是静态变量的引用。静态变量的存储空间不会由于函数调用的返回而被摧毁，因此，这样做是没有问题的。

执行结果如下：

第一次打印rd的值发生了很大的变化，这是因为26行函数的调用，改变了栈空间中的数据。第二次打印rd同理。

小结：

　　引用作为变量别名而存在旨在代替指针

　　const引用可以使得变量具有只读属性

　　引用在编译器内部使用指针常量实现

　　引用的最终本质为指针

　　引用可以尽可能的避开内存错误