C++中的引用

 

引用就是某个目标变量的别名，对引用的操作与对变量的直接操作效果完全相同。

引用的声明方法：类型标识符 &引用名=目标变量名；

　　如下：定义引用ra，它是变量a的引用，即别名。

　　　　

int a;

 int &ra=a;

1）  声明一个引用，必须进行初始化。

2）引用声明完毕后，相当于目标变量有两个名称即该目标原名称和引用名，且不能再把该引用名作为其他变量名的别名。

3）引用本身不是一种数据类型，因此引用本身不占存储单元，系统也不会给引用分配存储单元。

4）不能建立数组的引用。因为数组是一个由若干个元素所组成的集合，所以无法建立一个数组的别名。

 

引用的本质是： 引用在C++中的内部实现是一个常量指针。

Type &name  < ==>  Type * const name  (即指针的值不能被修改)

 

将 “引用” 做函数参数有哪些特点？

 

1）传递引用给函数跟传递指针的效果是一样的。

 

2) 使用引用传递函数的参数，在内存中没有产生实参的副本，它是直接对实参的操作。 而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递是对象，还将调用拷贝构造函数。因此，在参数传递的数据较大时，用引用比用一般变量传递参数效率和所占空间都好。

 

3） 虽然用指针作为函数参数也能达到同样的效果。但是，在被调用函数中 同样要给形参分配存储单元，而且重复使用“*指针变量名”的形式进行操作，很容易产生错误且程序的阅读性较差，另一方面，在主调函数的调用点处，必须使用变量的地址作为实参。而引用更容易，更清晰。

 

函数返回值是引用（引用当左值）

 

1 当函数返回值为引用时

若返回的是栈变量，不能成为其他引用的初始值，不能作为左值使用。

include <iostream>
using namespace std;

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

//返回a的本身 返回a的一个副本 10 
int& getAA2()
{
    int a ; //如果返回栈上的引用, 有可能会有问题
    a = 10;
    return a;
}

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

void main()
{
    int a1 = 0;
    int a2 = 0;
    a1 = getAA1();

    a2 = getAA2();   // a2 = 10

int &a3 = getAA2(); ////若返回栈变量 不能成为其它引用的初始值，关键是看变量是不是被编译器回收了
printf("a1:%d \n", a1);
printf("a2:%d \n", a2);
printf("a3:%d \n", a3);// 相当于*a3 去读取值，可是此时局部变量已经被回收，因此是乱码 
system("pause");
return 0;
}

2 若返回静态变量或全局变量

可以成为其他引用的初始值，即可作为左值使用，或者右值使用。

 

指针的引用

 

指针的引用：引用是一个指针的类型。  

Type*   &name   可以用指针的引用，做函数参数 来实现  函数参数二级指针做输出的模型。

#include <iostream>
using namespace std;

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


//在被调用函数 获取资源 
int getTeacher(Teacher **p)
{
    Teacher *tmp = NULL;
    if (p == NULL)
    {
        return -1;
    }
    tmp = (Teacher *)malloc(sizeof(Teacher));
    if (tmp == NULL)
    {
        return -2;
    }
    tmp->age = 33;
    // p是实参的地址  *实参的地址 去间接的修改实参的值
    *p = tmp; 
}


//指针的引用 做函数参数
int getTeacher2(Teacher* &myp)
{
    //给myp赋值 相当于给main函数中的pT1赋值
    myp = (Teacher *)malloc(sizeof(Teacher));
    if (myp == NULL)
    {
        return -1;
    }
    myp->age = 36;
}

void FreeTeacher(Teacher *pT1)
{
    if (pT1 == NULL)
    {
        return ;
    }
    free(pT1);
}

void main()
{
    Teacher *pT1 = NULL;

    //1 c语言中的二级指针
    getTeacher(&pT1);
    cout<<"age:"<<pT1->age<<endl;
    FreeTeacher(pT1);


    //2 c++中的引用 （指针的引用）
    //引用的本质 间接赋值后2个条件 让c++编译器帮我们程序员做了。
    getTeacher2(pT1);

    cout<<"age:"<<pT1->age<<endl;
    FreeTeacher(pT1);

    cout << "hello..." << endl;
    system("pause");
}

常引用  

1 在C++中可以使用变量初始const引用

 

const Type & name  = var；

const 引用让变量拥有只读属性

int a = 10;
const int &b = a;  //const 引用  使用变量a初始化

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

 

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

 

//int &m = 10; //引用是内存空间的别名 字面量10没有内存空间 没有方法做引用
const int &m = 10;

结论：

1） const & name  相当于 const int * const name；

2） 普通引用  相当于 int* const name;

3)  当使用常量（字面量）对const 引用进行初始化时，C++编译器会为常量分配空间，而字面量是放在代码区（没有内存空间），并把引用名作为这段空间的别名。

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