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引用初始化后，将生成一个只读变量。