10 - 引用

引用概念

C++中增加了引用的概念，引用可以看做是一个已定义变量的别名。引用的语法：Type& name = var;

void main()
{
    int a = 10; //c编译器分配4个字节内存。。。a内存空间的别名
    int &b = a;  //b就是a的别名。。。

    a =11; //直接赋值
    b  = 14; 

    printf("a:%d b:%d", a, b);
    system("pause");
}

 

引用做函数参数

//普通引用在声明时必须用其它的变量进行初始化，
//引用作为函数参数声明时不进行初始化

#include <iostream>

using namespace std;

struct Teacher
{
    char name[64];
    int age ;
};

void printfT(Teacher *pT)
{
    cout<<pT->age<<endl;
}

//pT是t1的别名 ,相当于修改了t1
void printfT2(Teacher &pT)
{
    //cout<<pT.age<<endl;
    pT.age = 33;
}

//pT和t1的是两个不同的变量
void printfT3(Teacher pT)
{
    cout<<pT.age<<endl;
   pT.age = 45; //只会修改pT变量 ,不会修改t1变量
}

void main()
{
    Teacher t1;
    t1.age = 35;

    printfT(&t1);

    printfT2(t1); //pT是t1的别名
    printf("t1.age:%d \n", t1.age); //33

    printfT3(t1) ;// pT是形参 ,t1 copy一份数据 给pT     //---> pT = t1
    printf("t1.age:%d \n", t1.age); //35
	
    cout<<"hello..."<<endl;    
    system("pause");
    return ;
}

 

引用的意义

引用作为其他变量的别名而存在，因此在一些场合可以代替指针。

引用相对于指针来说具有更好的可读性和实用性。

 

引用的本质

引用在C++中的内部实现是一个常量指针，Type& name == Type* const name

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

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

引用在实现上，只不过是把间接赋值成立的三个条件的后两步合二为一了。当实参传给形参引用的时候，只不过是C++编译器帮我们程序员取了一个实参地址，传给了形参引用。

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

 

函数返回值是引用

C++引用作为函数返回值时，如果返回的是栈变量，则不能成为其他引用的初始值，不能作为左值使用。如果返回的是静态变量或者全局变量，则可以成为其他引用的初始值，可以作为右值使用，也可以作为左值使用。

 

指针引用

#include <iostream>
using namespace std;

struct Teacher
{
    char name[64];
    int age;
};

int getTe(Teacher **myp )
{
    Teacher *p = (Teacher *)malloc(sizeof(Teacher));
	
    if (p ==NULL)
    {
        return -1;
    }
    memset(p, 0, sizeof(Teacher));
    p->age = 33;

    *myp  = p; 
    return 0;
}

//指针的引用而已
int getTe2(Teacher*  &myp)
{
    myp = (Teacher *)malloc(sizeof(Teacher));
    myp->age = 34;

    return 0;
}

void main333()
{
    Teacher *p = NULL;
    //getTe(&p);
    getTe2(p);

    printf("age:%d \n", p->age);
    system("pause");
}

 

常引用

使用变量初始化const引用

在C++中可以声明const引用，const引用让变量拥有只读属性。

int main()
{
    int a = 10;
    const int &b = a; 

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

    cout<<"b--->"<<a<<endl;
    printf("a:%d\n", a);
    printf("b:%d\n", b);
    printf("&a:%d\n", &a);
    printf("&b:%d\n", &b);
    system("pause");
    return 0;
}

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

void main()
{
    const int b = 10;
    printf("b:%d", &b);

    //int &a1 = 19; 如果不加const编译失败
    const int &a = 19;
    printf("&a:%d \n", &a);
    
    system("pause");
}

void 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;
    system("pause");
    return ;
}

当使用常量（字面量）对const引用进行初始化时，C++编译器会为常量值分配空间，并将引用作为这段空间的别名。使用字面量对const引用初始化后，将生成一个只读变量。