2. 引用

• 引用可以看作一个已经定义变量的别名
• 与原变量在同一片内存空间
• 引用语法： type& name = var;

int a = 4;
int& b =  a;  //b为a的别名
b = 5;          //操作b就是操作a

• 引用传递数组

fun(int (&array)[10]); 

普通引用在定义时必须用同类型变量进行初始化。

• 当三目运算符的可能返回都是变量时，返回的是变量引用
• 当三目运算符的可能返回中有常量时，返回的是值

int a = 1;
int b = 2;
(a<b?a:b) = 3;//正确，返回a或者b的引用，可以作为左值
(a<b?1:b) = 4;//错误，返回1或者b的值，不能作为左值

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

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

        int a = 4;
        const int& b = a;
        a = 3;          //编译通过
        b = 3;          //编译出错

使用常量对const引用初始化后将生成一个只读变量（不是常量，不会进入常量表）

• 引用有自己的存储空间，因为其本质就是指针
  
  • 引用在 c++ 内部实现是一个指针常量
  • c++编译器在编译过程中使用指针常量作为引用的内部实现，因此== 引用的空间大小和指针相同 ==

void f(int& a) <==> void f(int* const a)
{                   {
    a = ..                *a = ..
}                   }
int& a   <==> int* const a

#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\n", sizeof(char&));      //1
    printf("sizeof(rc) = %d\n", sizeof(rc));            //1

    printf("sizeof(TRef) = %d\n", sizeof(TRef));        //4
    printf("sizeof(ref.r) = %d\n", sizeof(ref.r));      //1

    return 0;
}

#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));                                  //12
    printf("sizeof(r.before) = %d\n", sizeof(r.before));                    //4
    printf("sizeof(r.after) = %d\n", sizeof(r.after));                      //4
    printf("&r.before = %p\n", &r.before);                                  //4
    printf("&r.after = %p\n", &r.after);

    return 0;
}

函数返回引用

• 不能返回局部变量的引用（因为引用内部使用常量指针实现，相当于返回局部变量的地址）

#include <stdio.h>

int& demo()  //int * const
{
    int d = 0;

    printf("demo: d = %d\n", d);

    return d;   //错误
}

int& func()
{
    static int s = 0;                   //全局存储区，所以可以返回引用

    printf("func: s = %d\n", 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;
}