C++ 中的引用

#include <iostream>
using namespace std;

void Swap(char* & rp, char* & rq)
{
    char *t = rp;
    rp = rq;
    rq = t;
}

void Swap(int& rp, int& rq)
{
    int t = rp;
    rp = rq;
    rq = t;
}

void Swap(int* rp, int* rq)
{
    int t = *rp;
    *rp = *rq;
    *rq = t;
}
int foo()
{
    int a = 100;
    return a;
}

int main()
{
    int a1, b1;
//    int &ra;        //引用在声明时就必须初始化，一经初始化，不可更改
    int &ra1 = a1;   //在编译阶段确定关系
    ra1 = b1;       //引用在声明时初始化后，不可更改，此处不是将ra1变为b1的引用，此处是将b1的值赋值给ra1,此时a1的值也随之改变了
//    float &rb1 = b1;//引用需与原类型保持一致
    cout<<"a1 address: "<<&a1<<endl;
    cout<<"ra1 address: "<<&ra1<<endl;

    int &rra1 = a1;   //可以给原类型再次声明一个别名，即一个变量可以声明多个别名
    int &rrb1 = ra1;  //也可对原类型别名再次声明一个别名，还是原类型的别名，即一个变量可以有很多个别名
    /*-------------------------------------------------------------*/
    int * p1;
    int * & rp1 = p1;    //声明一个指针的引用，也就是说这个rp1就是p1的别名
    int ** pprp1 = &rp1;  //一个指向引用的地址的指针
//    int &* prp1 = &rp1;  //引用的指针不存在的，不能定义一个指向引用的指针
    /*-------------------------------------------------------------*/
    int *p2;
    int * * pp2= &p2;
    int a2;
    int & rx2 = a2;
//    int && rrz2 = rx2;   //引用的引用，不存在的，在C++11之后是引用的引用
    /*-------------------------------------------------------------*/
    int a3, b3, c3;
    int * pArr3[] = {&a3, &b3, &c3};  //定义一个指针数组
//    int & rArr3[] = {a3, b3, c3};     //定义一个引用数组，不能建立一个引用的数组，不合法的。其rArr3本质是int & *，不存在的

    int array3[5] = {100, 200, 300, 400, 500};
//    int * & r3 = array3;
//    int * & pr3 = array3;
    int * const & ppr3 = array3;
    cout<<"sizeof(ppr3) = "<<sizeof(ppr3)<<endl;
    /*-------------------------------------------------------------*/
    int * AppendixpArr3[] = {&a3, &b3, &c3};  //定义一个指针数组
    int (*ppArr3)[5] = &array3;  //定义一个数组指针
    cout<<"*ppArr3 = "<<*ppArr3<<endl;
    cout<<"**ppArr3 = "<<**ppArr3<<endl;
    cout<<"*(ppArr3 + 1) = "<<*(ppArr3 + 1)<<endl;
    cout<<"(*ppArr3 +1) = "<<(*ppArr3 + 1)<<endl;
    cout<<"*(*ppArr3 +1) = "<<*(*ppArr3 + 1)<<endl;

    int (&ra3)[5] = array3;    //定义一个数组的引用
    cout<<"sizeof(ra3) = "<<sizeof(ra3)<<endl;
    /*----------------- --------------------------------------------*/
    const int val4 = 10; //const定义时必须初始化
//    int & rv4 = val4;
    const int & rrv4 = val4;

    int data4;
    int &rd4 = data4;
    const int &rrd4 = data4;

//    int & c5 = 55;    //引用是为已有变量取一个别名
    const int & cc5 = 55;

    int a5 = 3;
    int b5 = 5;
//    int &rret5 = a5 + b5;
    const int &rrret5 = 3 + 5;
    const int &rrrret5 = a5 + b5;
    /*-------------------------------------------------------------*/
//    int& ra6 = foo();
    const int& rra6 = foo();
    cout<<"ra6 = " << rra6 << endl;
    /*-------------------------------------------------------------*/
    double d7 = 100.12;
//    int &rd7 = d7;
    const int &rrd7 = d7;

    int a7 = 10;
    const int &ra7 = a7;
    int const &rb7 = a7;
//    ra7 = 100;
//    rb7 = 200;
//    int & const rc7 = a7; //'const' qualifiers cannot be applied to 'int&'
    /*-------------------------------------------------------------*/
    int a =10; int b = 20;
    Swap(&a, &b);
    Swap(a, b);
    return 0;
}

/* 引用的本质int & ~ int * const; const引用：const int & ~ const int * const
 * 1 变量名本身就是一段内存的引用，即变量名是一段内存的别名。编译过后，在内存中a是不存在的
 * 1 引用是一种关系型声明，而非定义。不能独立存在，必须初始化且与原类型保持一致，且不分配内存。
 * 2 声明关系，一经不可变更。
 * 3 可对引用再次引用，多次引用的结果是某一个变量具有多个别名，多个别名间是平等关系。
 * 4 辨别引用与其它，&符号前有数据类型时，是引用其它皆为取地址或按位与。
*/

struct TypeP
{
    char *p;
};
struct TypeC
{
    char c;
};
struct TypeR
{
    char& r; //把引用单列出来，不与具体的对象发生关系
};
int size()
{
    printf("%d %d %d\n", sizeof(TypeP),sizeof(TypeC),sizeof(TypeR));
    return 0;
}