C++关于指针，引用，函数和const的关系

C++知识梳理

指针与引用的区别

首先引用是对指针进行了简单的封装，它的底层依然是通过指针实现的。
有的说法说是引用自身不占内存，和其被引用对象占同一内存，这是比较浅显的。引用占用的内存和指针占用的内存长度一样，在 32 位环境下是 4 个字节，在 64 位环境下是 8 个字节，之所以不能获取引用的地址，是因为编译器进行了内部转换。
int a = 1; int &r = a; r = 2; cout<<&r<<endl;
当&a取地址时，编译器会对代码进行隐式的转换，使得代码输出的是 r 的内容（a 的地址），而不是 r 的地址，这就是为什么获取不到引用变量的地址的原因。也就是说，不是变量 r 不占用内存，而是编译器不让获取它的地址。

其具体区别是：

1. 引用必须在定义时初始化，并且以后也要从一而终，不能再指向其他数据；而指针没有这个限制，指针在定义时不必赋值，以后也能指向任意数据。
2. 可以有 const 指针，但是没有 const 引用。（因为引用本来就不能改变指向，加上 const 是多此一举。）
3. 指针可以有多级，但是引用只能有一级，例如，int **p是合法的，而int &&r是不合法的。如果希望定义一个引用变量来指代另外一个引用变量，那么也只需要一个&即可。
4. 指针和引用的自增（++）自减（–）运算意义不一样。对指针使用 ++ 表示指向下一份数据，对引用使用 ++ 表示它所指代的数据本身加 1；自减（–）也是类似的道理。
   5)指针自身被分配有内存地址，对指针本身取地址会取得该指针在内存中的地址；引用也有，但是对其取地址时被编译器做了转换，只能取得被引用对象的地址。

指针和引用的在临时数据上的限制

我们知道，指针就是数据或代码在内存中的地址，指针变量指向的就是内存中的数据或代码。这里有一个关键词需要强调，就是内存，指针只能指向内存，不能指向寄存器或者硬盘，因为寄存器和硬盘没法寻址。

其实 C++ 代码中的大部分内容都是放在内存中的，例如定义的变量、创建的对象、字符串常量、函数形参、函数体本身、new或malloc()分配的内存等，这些内容都可以用&来获取地址，进而用指针指向它们。除此之外，还有一些我们平时不太留意的临时数据，例如表达式的结果、函数的返回值等，它们可能会放在内存中，也可能会放在寄存器中。一旦它们被放到了寄存器中，就没法用&获取它们的地址了，也就没法用指针指向它们了。

    int n = 100, m = 200;
    int *p1 = &(m + n);    //m + n 的结果为 300
    int *p2 = &(n + 100);  //n + 100 的结果为 200
    bool *p4 = &(m < n);   //m < n 的结果为 false    

以上表达式均会报错。

由于寄存器离 CPU 近，并且速度比内存快，将临时数据放到寄存器是为了加快程序运行。但是寄存器的数量是非常有限的，容纳不下较大的数据，所以只能将较小的临时数据放在寄存器中。int、double、bool、char 等基本类型的数据往往不超过 8 个字节，用一两个寄存器就能存储，所以这些类型的临时数据通常会放到寄存器中；而对象、结构体变量是自定义类型的数据，大小不可预测，所以这些类型的临时数据通常会放到内存中。

同时，常量表达式的值虽然在内存中，但是没有办法寻址，所以也不能使用&来获取它的地址，更不能用指针指向它。如以下代码段也是错误的。

    int *p1 = &(100);
    int *p2 = &(23 + 45 * 2);

Const和引用结合使用时

引用不能绑定到临时数据，这在大多数情况下是正确的，但是当使用 const 关键字对引用加以限定后，引用就可以绑定到临时数据了。如以下代码在 GCC 和 Visual C++ 下都能够编译通过。

//环境代码：
typedef struct{
    int a;
    int b;
} S;
//此段代码验证当返回值是结构体类型时，返回值是在内存区域而不是寄存器的
S func_s(){
    S a;
    a.a = 100;
    a.b = 200;
    return a;
}
//此段代码用运算符重载来返回一个结构体变量，来验证当返回值是结构体类型时，返回值是在内存区域而不是寄存器的
S operator+(const S &A, const S &B){
    S C;
    C.a = A.a + B.a;
    C.b = A.b + B.b;
    return C;
}

    int m = 100, n = 36;
    const int &r1 = m + n;
    const int &r2 = m + 28;
    const int &r3 = 12 * 3;
    const int &r4 = 50;
    const int &r5 = func_int();
    //下面的代码在GCC下是错误的，在Visual C++下是正确的  但是若是在S前加上Const那么都能通过编译
    S s1 = {23, 45};
    S s2 = {90, 75};
    S &r6 = func_s();
    S &r7 = s1 + s2;

这是因为将常引用绑定到临时数据时，编译器采取了一种妥协机制：编译器会为临时数据创建一个新的、无名的临时变量，并将临时数据放入该临时变量中，然后再将引用绑定到该临时变量。注意，临时变量也是变量，所有的变量都会被分配内存。

为什么编译器为常引用创建临时变量是合理的，而为普通引用创建临时变量就不合理呢？

1. 我们知道，将引用绑定到一份数据后，就可以通过引用对这份数据进行操作了，包括读取和写入（修改）；尤其是写入操作，会改变数据的值。而临时数据往往无法寻址，是不能写入的，即使为临时数据创建了一个临时变量，那么修改的也仅仅是临时变量里面的数据，不会影响原来的数据，这样就使得引用所绑定到的数据和原来的数据不能同步更新，最终产生了两份不同的数据，失去了引用的意义。

    void swap(int &r1, int &r2){
        int temp = r1;
        r1 = r2;
        r2 = temp;
    }

如上段代码，如果编译器会为 r1、r2 创建临时变量，那么函数调用swap(10, 20)就是正确的，但是 10 不会变成 20，20 也不会变成 10，所以这种调用是毫无意义的。

总起来说，不管是从“引用的语义”这个角度看，还是从“实际应用的效果”这个角度看，为普通引用创建临时变量都没有任何意义，所以编译器不会这么做。

2. const 引用和普通引用不一样，我们只能通过 const 引用读取数据的值，而不能修改它的值，所以不用考虑同步更新的问题，也不会产生两份不同的数据。
   这样为 const 引用创建临时变量的时候，引用的意义没有丝毫动摇，反而增进了引用的灵活性和通用，相当巧妙。

const 引用与类型转换

「类型严格一致」是为了防止发生让人匪夷所思的操作，但是这条规则仅仅适用于普通引用，当对引用添加 const 限定后，情况就又发生了变化，编译器允许引用绑定到类型不一致的数据。请看下面的代码：

int n = 100;
int &r1 = n;  //正确
const float &r2 = n;  //正确

char c = '@';
char &r3 = c;  //正确
const int &r4 = c;  //正确 

当引用的类型和数据的类型不一致时，如果它们的类型是相近的，并且遵守「数据类型的自动转换」规则，那么编译器就会创建一个临时变量，并将数据赋值给这个临时变量（这时候会发生自动类型转换），然后再将引用绑定到这个临时的变量，这与「将 const 引用绑定到临时数据时」采用的方案是一样的。

注意，临时变量的类型和引用的类型是一样的，在将数据赋值给临时变量时会发生自动类型转换。请看下面的代码：

float f = 12.45;
const int &r = f;
printf("%d", r);

该代码的输出结果为 12，说明临时变量和引用的类型都是 int（严格来说引用的类型是 int &），并没有变为 float。

当引用的类型和数据的类型不遵守「数据类型的自动转换」规则，那么编译器将报错，绑定失败，例如：

    char *str = "abcd";
    const int &r = str;

char *和int两种类型没有关系，不能自动转换，这种引用就是错误的。

结合上面讲到的知识，总结起来说，给引用添加 const 限定后，不但可以将引用绑定到临时数据，还可以将引用绑定到类型相近的数据，这使得引用更加灵活和通用，它们背后的机制都是临时变量。

引用类型的函数形参请尽可能的使用 const

当引用作为函数参数时，如果在函数体内部不会修改引用所绑定的数据，那么请尽量为该引用添加 const 限制。

概括起来说，将引用类型的形参添加 const 限制的理由有三个：

使用 const 可以避免无意中修改数据的编程错误；
使用 const 能让函数接收 const 和非 const 类型的实参，否则将只能接收非 const 类型的实参；
使用 const 引用能够让函数正确生成并使用临时变量。