【C++】5.引用的本质分析

 

引用的意义

• 引用作为变量的别名而存在，因此在一些场合中可以代替指针
• 引用相对于指针来说更具有更好的可读性和实用性

swap 函数的对比

// 指针版本
void swap(int *a, int *b)
{
    int t = *a;
    *a = *b;
    *b = t
}

// 引用版本(注意：函数中的引用行参不需要进行初始化！！！)
void swap(int& a, int& b)
{
    int t = a;
    a = b;
    b = c;
}

函数对比分析：

1. 引用如果作为函数的形参时，不需要进行初始 初始化发生在调用的时候。
2. 指针版本要交换a和b的值，传进去的是a和b的地址，想想其实是很奇怪的，引用给人感觉很舒服多了

特殊的引用：const 引用

• 在C ++ 中可以声明 const 引用

const Type& name = var

• const 引用让变量拥有只读属性

int a = 4;
const int& b = a;
int *p = (int*)&b;

b = 5; // error  b是只读变量
*p = 5; // ok 还是可以修改 a 的值的
// 只读变量直接赋值是错误的， 但还是可以通过指针改变里面的值

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

const int& b = 1;
int *p = (int*)&b;
b = 5; // error 只读变量
*p = 5 // ok 

使用常量对 const 引用初始化后将生成一个只读变量

#include <stdio.h>

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

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

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

    return 0;
}

 

 

思考：

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

struct Tref
{
    char& c;
};

cout << sizeof(Tref) << endl;

#include <stdio.h>


struct Tref
{
	char& c;
};

int main(int argc, char *argv[])
{
	
	char c = 'C';
	char& rc = c;
	Tref ref = {c};
	

	
	printf("sizeof(char&) = %d\n", sizeof(char&));  // 1
    printf("sizeof(rc) = %d\n", sizeof(rc));        // 1
    
    printf("sizeof(Tref) = %d\n", sizeof(Tref));    // ?
    printf("sizeof(ref.c) = %d\n", sizeof(ref.c));  // 1
	
}

输出

sizeof(char&) = 1
sizeof(rc) = 1
sizeof(Tref) = 8    // 让人联想是否为指针
sizeof(ref.c) = 1

 

引用的本质

引用很多行为类似与指针 因为本质如下：

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

Type& name
等效
Type* const name

void func(int& a)
{
    a = 5;
}

void func(int* const a)
{
    *a = 5;
}

注意：

1. C++ 编译器在编译过程中用 指针常量 作为引用的内部实现，因此引用所占用的空间大小与指针相同
2. 从使用角度，引用只是一个别名， 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\n", sizeof(r));
    printf("sizeof(r.before) = %d\n", sizeof(r.before));
    printf("sizeof(r.after) = %d\n", sizeof(r.after));
    printf("&r.before = %p\n", &r.before);
    printf("&r.after = %p\n", &r.after);

    return 0;
}

 

在 Linuc 64位机器下编译结果

sizeof(r) = 24
sizeof(r.before) = 8
sizeof(r.after) = 8
&r.before = 0x7ffc17a6c4c0
&r.after = 0x7ffc17a6c4d0

 

汇编代码分析（VS2013，32位编译器）

char a = 'a';
008E3B38  mov         byte ptr [a],61h  

16进制数 61h 送到 a 这个标识符的内存空间，大小是一个 Byte

char& b = a;
008E3B3C  lea         eax,[a]  // 
008E3B3F  mov         dword ptr [b],eax  

a 的地址取出来，放到 eax 这个寄存器中去

将 eax 里面的内容，送到一片内存空间里去，这片内存空间就是 b 标识符对应的内存空间，大小为 dword ，即4个字节

 

C++ 中引用旨在大多数的情况下代替指针

• 功能性：可以满足多数需要使用指针的场合
• 安全性：可以避开由于指针操作不当而带来的内存错误
• 操作性：简单易用，又不失功能强大

生成了只读变量，直接对只读变量修改是不行的

要使已经存在的变量（变成只读属性），只要定义一个它的const的引用

函数返回引用分析

#include <stdio.h>

int& demo()
{
    int d = 0;
    
    printf("demo: d = %d\n", d);
    
    return d;   // return &d; // 返回局部变量的引用
}

int& func()  // int* const
{
    static int s = 0;
    
    printf("func: s = %d\n", s);
    
    return s;   // return &s;
}

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

demo: d = 0
func: s = 0

Segmentation fault (core dumped)

不要返回局部变量的引用（这个本质在C看来就是不能返回局部变量的指针）。

如果这个局部变量被static修饰 就是可以返回（因为此时的变量存储在全局数据区）。

返回的是局部变量的地址（local variable），main 中rd已经是野指针了，已经没有意义了

小结

• 引用作为变量别名而存在旨在代替指针
• const 引用可以使得变量具有只读属性
• 引用在编译器内部使用 指针常量实现
• 引用的最终本质为指针
• 引用可以尽可能的避开内存错误