c++学习基础篇（2)——引用（&）的用法与应用

Posted 2021-07-26 Tiramisu1104

一、引用简介

1、引用的概念

     引用是个别名，当建立引用时，程序用另一个变量或者对象的名字初始化它。对引用的改动实际就是对目标的改动。

    为建立引用，先写上目标的类型，后跟引用运算符“&”，然后就是引用的名字。引用能使用任何合法变量名。

i

int someInt;
int& rInt= someInt;

声明rInt是对整数的引用，初始化为引用someInt。引用不是值，不占内存空间，声明引用时，目标的存储状态不会改变。所以既然定义的概念有具体分配空间的含义，那么引用只有声明，没有定义。

#include<iostream>
using namespace std;
int main() {
    int intOne = 5;
    int& rInt = intOne;
    cout << "intOne:" << intOne << endl;
    cout << "rInt:" << rInt << endl;
    rInt = 7;
    cout << "intOne:" << intOne << endl;
    cout << "rInrL" << rInt << endl;
}

运行结果：

intOne:5
rInt:5
intOne:7
rInrL7

2、引用的操作

如果程序寻找被引用的地址，他只能找到所引用的目标的地址。

#include <iostream>
using namespace std;
int main() {
    int intOne = 5;
    int& rInt = intOne;
    cout << "intOne:" << intOne << endl;
    cout << "rInt:" << rInt << endl;
    cout << "&intOne:" << &intOne << endl;
    cout << "&rInt:" << &rInt << endl;
}

运行结果：

intOne:5
rInt:5
&intOne:003BF78C
&rInt:003BF78C

3、什么能被引用

如果一个变量声明为T&，即引用时，他必须用T类型的变量或对象进行初始化，或能够转换成T类型的对象进行初始化。

double&rr = 1 是合法的

在这种条件下：

（1）首先作必要的类型转换，；

（2）然后将结果置为临时变量；

（3）最后把临时变量的地址作为初始化的值。

4、用引用传递函数参数

（1）引用传递参数

传递引用给函数与传递指针的效果一样，传递的是原来的变量或者对象，而不是在函数作用域内建立变量或者对象的副本。

#include <iostream>
using namespace std;
void swap(int& rx, int& ry) {
    int temp = rx; rx = ry; ry = temp;
}
int main() {
    int x = 5, y = 6;
    cout << "before swap,x:" << x << ",y:" << y << endl;
    swap(x, y);
    cout << "after awap,x:" << x << ",y:" << y << endl;
    return 0;
}

运行结果：

before swap,x:5,y:6
after awap,x:6,y:5

在主函数中，调用swap（）函数的参数是x和y,简单地传递变量而不是他们的地址。而事实上，传递的是他们的地址。

5、返回多个值

函数只能返回一个值。如果一个程序需要函数返回两个值怎么办？解决这一问题之一的办法就是之一是用引用给函数传递两个参数，然后由函数往目标中填入多个正确的值。

6、用引用返回值

函数返回值时，要生成一个值的副本。而用引用返回值时，不生成值的副本。

7、函数调用作为左值

返回一个引用使得函数调用表达式成为左值表达式。只要避免将局部栈中变量的地址返回，就能使函数表达式成为左值表达式。

#include <iostream>
using namespace std;
int arry[6][4] = { {60,80,90,75},
                {75,85,65,77},
                {80,88,90,98},
                {89,100,78,81},
                {62,68,69,75},
                {85,85,77,91} };
int getLevel(int grade[], int size);
int main() {
    int typeA = 0, typeB = 0;
    int student = 6;
    int gradesize = 4;
    for (int i = 0; i < student; i++)
        if (getLevel(arry[i], gradesize))
            typeA++;
        else
            typeB++;
    cout << "number of type A is " << typeA << endl;
    cout << "number of type B is " << typeB << endl;

}
int getLevel(int grade[], int size) {
    int sum = 0;
    for (int i = 0; i < size; i++)
        sum += grade[i];
    if (sum / size >= 80)
        return 1;
    else
        return 0;

}

运行结果

number of type A is 3
number of type B is 3

8、用const限定引用

传递指针或者引用更大的目的是效率，当一个数据类型很大时因为传值要复制副本，所以不可取。

另外传递指针和引用存在传值所没有的危险，程序有时不允许传递的指针所指向的值被修改或者传递引用被修改，但是传递的地址特征使得所传的参数处于随时被修改的危险之中。

保护实参不被修改的办法就是传递const指针和引用。

9、返回堆中变量的引用

对于引用 的初始化，可以是变量，可以是常量，也可以是一定类型的堆空间变量。但是由于引用不是指针，所以下面的代码直接堆中获得的变量空间来初始化引用是错误的。

#include <iostream>
using namespace std;
void fn()
{
    int* pInt = new int;
    if (pInt == NULL)
    {
        cout << "error memory alloation";
    }
    int& rInt = *pInt;
}

int指针pInt获得new返回的值，程序测试pInt中的地址，如果它是NULL，则报错并返回，如果它不是NULL，则将*pInt初始化引用rInt。因此rInt成为new返回int的别明白。