C++引用

引用是C++当中的一个概念。
引用，引用就是某一变量（目标）的一个别名，对引用的操作与对变量直接操作完全一样。
引用的声明方法：类型标识符 &引用名=目标变量名；

左值引用

首先说下左值和右值的概念。
右值是放在寄存器，cpu当中的 。
左值必须在内存当中存在实体。

左值引用，需要一个取&。

示例：

int main()
{
    int a (5);
    int &ra(a);
    ra = 3;
    cout << a << endl;
    system("pause");
    return 0;
}

在这里，ra就是a的别名，我们修改ra就是修改a。
引用必须初始化。引用有两种初始化方式，要么是=要么是（）。

引用的注意事项

引用是为对象建立一个别名。
一个变量可以有多个引用
引用必须初始化，且只能初始化一次，程序中引用不能再次进行初始化。
引用使用同一块地址，但是它们的名字不一样。
引用的本质依然是利用指针来实现的，只有左值引用是利用指针实现的。
引用加上const以后更安全

引用做参数

//函数进行引用传递。
void change(int &a)
{
    a = 59;
}
int main()
{

    int a(15);
    change(a);
    cout << a;
    system("pause");
    return 0;
}

这里，如果不进行引用传递，就进行的是传值调用，那样即耗费空间还无法改变外部变量的值。所以在这里我们采用引用传递，在我们编程的过程当中，要尽可能多的采用引用，这样可以更加高效。

引用修改值

```
int main()
{
    int num1(6);
    int num2(20);
    int *pnum(&num1);
    int* & rpnum=pnum;

    *rpnum = 100;
    cout << *pnum << endl;
    cout << num1;
    system("pause");
    return 0;

}

在上面这个程序当中，我们首先让指针pnum保存了num1的地址，然后rpnum是指针pnum的引用。
然后我们修改了*rpnum，其实就是修改了rpnum所指向的内容，也就是pnum所指向的内容，也就是num1；所以*pnum和num1都变成了100；

右值引用

右值存放在寄存器，是在cpu上。

//右值引用
int main()
{
    int num1(20);
    int *&&rpnum = &num1;

    system("pause");
    return 0;
}

上面这个程序就是引用右值的例子，在这里&num1就是右值。因为右值是在寄存器上的，如果我们要把他拿出来，需要进行拷贝，早期的c++采用的就是在内存开辟一块空间进行拷贝，然后进行操作，但是这样的话太浪费空间与时间。所以右值引用出现了。

//右值引用
//引用右值节约内存。
int getdata(int &&ra)
{
    ra +=  20;
    return ra;
}
int main()
{

    int a = 5;

    std::cout << getdata(a + 1) << std::endl;
    system("pause");
    return 0;
}

这里的a+1就是右值，传递进函数，这样采用右值引用进行操作，最终可以节省内存空间。

引用右值，需要两个&&，引用右值，可以在对象赋值的时候，不需要拷贝副本，直接可以引用右值。

引用右值，编译器会直接从寄存器拷贝出来，否则的话需要在内存当中拷贝一个副本，这样就节省了很多时间。右值引用在企业优化开发有很大的用处。

返回临时变量的引用

//返回临时变量的引用
int &get()
{
    int a(10);
    int &ra(a);
    cout << &a << endl;
    return ra;
}

int main()
{
    int &ra = get();
    cout << ra << endl;
    cout << "ABCDE" << endl;
    cout << ra << endl;
    system("pause");
    return 0;
}

上述这个程序在get函数中返回了临时变量的引用。在get函数当中，ra是a的别名，然后我们把ra返回了，ra是指向a那块内存的，a是栈上开辟的引用，但是，函数结束以后，会内存回收。然后虽然主函数当中的ra是指向那块内存，但是，当再次执行其他函数，如上述的cout<<“ABCDE”<<endl开辟栈帧，覆盖了那块空间的话，那么那块空间的内容就被修改了，所以第一次输出的ra和第二次输出的ra是不同的。

所以，在平时编程的时候，我们要注意，在引用栈上的内容时要特别注意临时变量的引用。

堆上的引用

示例：

//引用堆上的情况。
int* & getdata()
{
    int *p = new int; //开辟堆上的内存。
    cout << &p << endl;
    *p = 20;
    int * &rp = p;//引用指针。
    return rp;  //返回引用的指针。
}
int main()
{
    int * &rp = getdata();//用引用的指针接收引用的指针类型的返回值
    int *p = rp;    //用指针保留了堆上的地址，这就不会发生变化。
    cout << *rp << endl;//rp变成了野指针。
    cout << *p<< endl;
    cout << *rp << endl;
    cout << *p << endl;

    delete(p);//回收内存，后续的操作不能进行对堆上内存相关的操作。
                //指针的值也要发生改变。

    system("pause");
    return 0;
}

在这里，我们new所开辟的空间是在堆上的。在这里整个函数结束完后会返回一个地址，*rp是这个地址的引用，但是当输出一次这个地址的内容以后，主函数当中的rp变成了野指针。这样最终*rp就发生了变化。但是，我们把刚返回来的这一块内存地址给记住以后，这块堆上开辟的地址内容是不变的。
最后，要说的是delete关键字，这个关键字回收内存，C++中的delete，为了安全性，当你回收了以后，就禁止你访问。
所以最终就可以知道的是，左值在栈上返回的引用会发生变化，而在堆上返回的引用不会发生变化。

数组的引用

//数组的引用。
int main()
{
    int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int(&ra)[10](a);//这里对引用进行初始化。
    int i = 0;
    for (auto data : ra)
    {
        data = i + 5;
        cout << data << endl;
    }
    cout << a << "  " << ra << endl;
    system("pause");
    return 0;
}

在这里我们需要注意的是对数组引用进行初始化。然后下面的for循环是采用泛型 auto循环一维数组。

二位数组的引用

//二维数组的引用
int main()
{
    int a[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int(&ra)[2][5](a);//
    int i = 0;
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 5;j++)
        {
            cout << a[i][j]<<" ";
        }
        cout << endl;
    }
    system("pause");
    return 0;
}

二位数组的引用，类似与一维数组的引用。

函数指针的引用

//引用一个函数指针。
int add(int a, int b)
{
    return a + b;
}
int sub(int a, int b)
{
    return a - b;
}

void change(int(*& rp)(int a, int b))//改变函数指针，可以经常用在劫持
{
    rp = sub;

}
int main()
{
    int(*p)(int a, int b)(add);//p就是指向add的函数指针
    cout << p(1, 2) << endl;
    int(*& rp)(int a, int b)(p);//引用了一个函数指针
    change(p);
    cout << p(1, 2) << endl;
    system("pause");
    return 0;
}

函数指针也是可以进行引用的，这个时候我们要对函数指针进行初始化，要注意初始化的形式，上述的程序通过change函数改变了函数指针的指向函数。

返回值是一个函数的引用

//返回值是一个函数的引用。

int add(int a, int b)
{
    return a + b;
}
int sub(int a, int b)
{
    return a - b;
}

int(*& changep(int(*& rp)(int a, int b)))(int a,int b)//返回函数指针的引用
{
    rp = sub;
    return rp;

}
int main()
{
    int(*p)(int a, int b)(add);//p就是指向add的函数指针
    cout << p(1, 2) << endl;
    int(*& rp)(int a, int b)(p);//引用了一个函数指针
    p=changep(p);
    cout << p(1, 2) << endl;
    system("pause");
    return 0;
}

类似于上面的程序只不过这里是返回的是函数指针的引用。

int(*& changep(int(*& rp)(int a, int b)))(int a,int b)

这样的东西真心面试题喜欢出

例如：int (* & z(int x,int (* & y)(int)))(int)
这里的z是一个参数是整形的x和一个函数指针的引用，返回值是一个函数指针的引用

数组与引用

在数组当中，引用数组是非法的。也就是不可以数组的每个元素都是引用。
所以想管理每个引用，还是采用指针数组。

int main()
{
    int a = 1, b = 3, c = 5;
    int *px[3] = { &a, &b, &c };//指针数组中是引用是合法的，
                                //数组每个元素都是引用是不合法的

    system("pause");
    return 0;
}

引用的大小

//引用的大小
class myclass
{

public:
    int &a; 
    double &c;
    char b;

};

在这，如果是在类中，要求引用的大小，我们就把引用当作指针。类就相当于结构体，我们按照结构体的内存对齐的规则进行计算，可以得出这个类的大小就是12。

int main()
{
    int num = 10;
    int &rnum(num);
    double db= 10.9;
    double &rdb(db);

    cout << sizeof(rdb) << endl;
    system("pause");
    return 0;
}

这里是直接求引用，这就是求引用变量的大小，就是double类型的变量db的大小。大小是8。

引用的本质就是指针，直接sizeof引用，就是引用变量的大小。如果引用在类当中，引用就是类似于指针。

引用和指针的区别和联系

1 . 引用只能在定义时初始化一次，之后不能改变指向其它变量（从一而终）；指针变量的值可变。
2 . 引用必须指向有效的变量，指针可以为空。
3 . s izeof指针对象和引用对象的意义不一样。s izeof引用得到的是所指向的变量的大小，而s izeof指针是对象地址的大小。
4 . 指针和引用自增(+ + )自减(- - )意义不一样。
5 . 相对而言，引用比指针更安全。

总结

（1）在引用的使用中，单纯给某个变量取个别名是毫无意义的，引用的目的主要用于在函数参数传递中，解决大块数据或对象的传递效率和空间不如意的问题。

　　（2）用引用传递函数的参数，能保证参数传递中不产生副本，提高传递的效率，且通过const的使用，保证了引用传递的安全性。

　　（3）引用与指针的区别是，指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差；而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。

　　（4）使用引用的时机。流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。