---

普通引用

概念

• 引用可以看作一个已定义变量的别名
• 引用的语法：Type& name = var;

int main()
{
    int a = 10;  //c编译器分配4个字节内存。。。a内存空间的别名
    int &b = a;  //b就是a的别名。。。
    a = 11;      //直接赋值
    
    int *p = &a;
    *p = 12;
    printf("a = %d \n",a);  // a = 12
    
    b = 14; 
    printf("a = %d, b = %d\n", a, b); // a = 14, b = 14
    
    return 0;
}

• 属于C++编译器对C的扩展

引用做函数参数

• 引用作为函数参数声明时不进行初始化
• 引用作为其它变量的别名而存在，因此在一些场合可以代替指针
• 引用相对于指针来说具有更好的可读性和实用性

引用的本质

1）引用在C++中的内部实现是一个常指针

Type& name  =>  Type* const name

2）C++ 编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。

3）从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间。这是C++为了实用性而做出的细节隐藏

引用结论

1）引用在实现上，只不过是把：间接赋值成立的三个条件的后两步和二为一

//当实参传给形参引用的时候，只不过是c++ 编译器帮我们程序员手工取了一个实参地址，传给了形参引用（常量指针）

2）当我们使用引用语法的时，我们不去关心编译器引用是怎么做的。当我们分析奇怪的语法现象的时，我们才去考虑c++编译器是怎么做的

函数返回值是引用

C++ 引用使用时的难点：

当函数返回值为引用时
    若返回栈变量
    不能成为其它引用的初始值
    不能作为左值使用
若返回静态变量或全局变量
    可以成为其他引用的初始值
    即可作为右值使用，也可作为左值使用
C++链式编程中，经常用到引用，运算符重载专题

返回值是基础类型，当引用

int getAA1()
{
    int a;
    a = 10;
    return a;
}

//基础类型a返回的时候，也会有一个副本
int& getAA2()
{
    int a;
    a = 10;
    return a;
}

int* getAA3()
{
    int a;
    a = 10;
    return &a;
}

返回值是static变量，当引用

//static修饰变量的时候，变量是一个状态变量
//j()的运算结果是一个数值，没有内存地址，不能当左值。。。。
int j()
{
    static int a = 10;
    a ++;
    printf("a:%d \n", a);
    return a;

}

//当被调用的函数当左值的时候，必须返回一个引用。。。。。

int& j1()
{
    static int a = 10;
    a ++;
    printf("a:%d \n", a);
    return a;
}

int *j2()
{
    static int a = 10;
    a ++;
    printf("a:%d \n", a);
    return &a;
}

返回值是形参，当引用

int  g1(int *p)
{
    *p = 100;
    return *p;
}

int&  g2(int *p) //
{
    *p = 100;
    return *p;
}

返回值非基础类型 ==是一个类，那么情况非常赋值。。涉及到copy构造函数和=操作重载，抛砖。。。。==

指针引用

//指针的引用而已

---

常引用 -- const 引用

1 使用变量初始化const引用

    int a = 10;
    const int &b = a; 

    int *p = (int *)&b;
    // b = 11;  //err
    *p = 11;    //只能用指针来改变了

    const int &b = a; //const引用 使用变量a初始化
    a = 11;
    //b = 12; //通过引用修改a,对不起修改不了

//const引用让变量(所指内存空间)拥有只读属性

2使用字面量常量初始化const引用

    //int &a1 = 19; 如果不加const编译失败
    const int &a = 19;

思考：

1、用变量对const引用初始化，const引用分配内存空间了吗？ -- 会

2、用常量对const引用初始化，const引用分配内存空间了吗？ -- 会

3 const引用结论

1）Const & int e 相当于 const int * const e

2）普通引用 int &e1 相当于 int *const e1

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

4）使用字面量对const引用初始化后，将生成一个只读变量

4 const修饰类

5 综合案例

int main()
{
    //普通引用
    int a = 10;
    int &b = a;
    
    //常量引用 ：让变量引用只读属性
    const int &c = a;  

    //常量引用初始化 分为两种
    //1 用变量 初始化 常量引用
    {
        int x = 20;
        const int& y = x;
        printf("y:%d \n", y);
    }

    //2 用常量 初始化 常量引用
    {
        //int &m = 10; //引用是内存空间的别名 字面量10没有内存空间 没有方法做引用
        const int &m = 10; 
    }
    cout<<"hello..."<<endl;
    
    return 0;
}