C++入门(一)：引用(左值引用)

龙俊杰的读书笔记

已于 2022-09-27 19:36:39 修改

阅读量946

点赞数 2

分类专栏： C++语法基础文章标签： c++ 开发语言

于 2022-09-27 19:18:34 首次发布

本文链接：https://blog.csdn.net/u011852872/article/details/127076811

版权

C++语法基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

快速入门

前置知识

内存拷贝，是指将一块内存上的数据复制到另一块内存上；赋值就是对内存进行拷贝。
数组、结构体、对象是一系列数据的集合，数据量可能多，对它们进行频繁的内存拷贝可能会消耗很多时间，降低程序执行效率。
C/C++ 在函数调用时，对于结构体和对象可以直接传递内容；但是为了提高效率，建议传递指针
char、int、float 等由语言本身支持的类型称为基本类型；将数组、结构体、类（对象）等由基本类型组合而成的类型称为聚合类型

引用的快速使用

C++ 中，有一种比指针更加便捷的传递聚合类型数据的方式，那就是引用（Reference）

引用（Reference）是 C++ 相对于C语言的又一个扩充。
语法格式为：

type &name = data;

type 是被引用的数据的类型，name 是引用的名称，data 是被引用的数据。

引用可以看做是数据的一个别名，通过这个别名和原来的名字都能够找到这份数据。
引用必须在定义的同时初始化，并且以后也要从一而终，不能再引用其它数据，但是引用的数据可以变更;如果期望引用的变量不可修改(只读属性)，可以加const限制
引用变量name和原变量data的地址(&name, &data)相同，可以通过name变量修改内存上的数据

函数传参的三种形式(输入或者输出)

#include <iostream>
using namespace std;
void swap1(int a, int b);
void swap2(int *p1, int *p2);
void swap3(int &r1, int &r2);
int main() {
    int num1, num2;
    cout << "Input two integers: ";
    cin >> num1 >> num2;
    swap1(num1, num2);
    cout << num1 << " " << num2 << endl;

    cout << "Input two integers: ";
    cin >> num1 >> num2;
    swap2(&num1, &num2);
    cout << num1 << " " << num2 << endl;

    cout << "Input two integers: ";
    cin >> num1 >> num2;
    swap3(num1, num2);
    cout << num1 << " " << num2 << endl;

    return 0;
//传值
void swap1(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
}
//传指针
void swap2(int *p1, int *p2) {
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}
//传引用
void swap3(int &r1, int &r2) {
    int temp = r1;
    r1 = r2;
    r2 = temp;
}

运行结果

Input two integers: 12 34
12 34
Input two integers: 88 99
99 88
Input two integers: 100 200
200 100

swap1() 直接传递参数的内容，不能达到交换两个数的值的目的。
- 对于 swap1() 来说，a、b 是形参，是作用范围仅限于函数内部的局部变量，它们有自己独立的内存(栈内)，和 num1、num2 指代的数据不一样。、
- 调用函数时分别将 num1、num2 的值传递(复制)给 a、b，此后 num1、num2 和 a、b 再无任何关系，在 swap1() 内部修改 a、b 的值不会影响函数外部的 num1、num2，更不会改变 num1、num2 的值。
swap2() 传递的是指针，能够达到交换两个数的值的目的。
- 调用函数时，分别将 num1、num2 的指针传递(复制)给 p1、p2，此后 p1、p2 指向 a、b 所代表的数据，在函数内部可以通过指针间接地修改 a、b 的值。
swap3() 是按引用传递，能够达到交换两个数的值的目的。
- 调用函数时，分别将 r1、r2 绑定到 num1、num2 所指代的数据，此后 r1 和 num1、r2 和 num2 就都代表同一份数据了，通过 r1 修改数据后会影响 num1，通过 r2 修改数据后也会影响 num2。

引用作为函数返回值

int &add(int &r) {
    r += 1;
    return r;
}

需要注意：不能返回局部变量r(变量在栈上，程序运行结束后会释放局部数据的管理权)。

引用的本质(*****)

引用本身占用内存吗

对于引用

int a = 99;
int &r = a;

通过 &r获取的是a的地址，那么r变量本身是否占用内存，下面通过实验说明。

#include <iostream>
#include <iomanip>
using namespace std;
int num = 99;
class A{
public:
    A();
private:
    int n;
    int &r;
};
A::A(): n(0), r(num){}
int main (){
    A *a = new A();
    cout<<sizeof(A)<<endl;
    cout<<hex<<showbase<<*((int*)a + 1)<<endl;  //输出r本身的内容
    cout<<&num<<endl;  //输出num变量的地址
    return 0;
}

运行结果

8
0x442000
0x442000

代码说明：

sizeof(A) 输出A类型的大小
成员变量 r 是 private 属性的，不能直接通过对象来访问，但是借助指针和类型转换，依然可以得到它的内容，第20行代码是用来输出 r 本身的内容；
hex表示以十六进制输出，showbase表示添加十六进制前缀0x。

结论：

sizeof(A) 占用8个字节，说明成员变量 r 是占用内存的
r 存储的内容是0x442000，也即变量 num 的地址
引用是对指针的封装(编译器层完成，用户没有感知)，底层依然是通过指针实现的，占用的内存和指针占用的内存长度一样，在 32 位环境下是 4 个字节，在 64 位环境下是 8 个字节；
引用r是占用内存的，但是编译器不让获取它的地址(编译器进行了内部转换)

实际上，编译器对引用建立的以下转换关系(相对于指针)：

引用的等价转换–变量

引用的形式

int a = 99;
int &r = a;
r = 18;
cout<<&r<<endl;

转换为指针形式

int a = 99;
int *r = &a;
*r = 18;
cout<<r<<endl;

引用的等价转换–函数

引用形式

//定义函数
void swap(int &r1, int &r2){
    int temp = r1;
    r1 = r2;
    r2 = temp;
}
//调用函数
int num1 = 10, num2 = 20;
swap(num1, num2);

转换为指针

//定义函数
void swap(int *r1, int *r2){
    int temp = *r1;
    *r1 = *r2;
    *r2 = temp;
}
//调用函数
int num1 = 10, num2 = 20;
swap(&num1, &num2);

引用与指针的区别

引用必须在定义时初始化，并且以后不能再指向其他数据；
指针可以有多级，但是引用只能有一级 int &&r是不合法的(&& 在C++ 11中表示右值引用)；
对指针使用 ++ 表示指向下一份数据，对引用使用 ++ 表示它所指代的数据本身加 1；

引用不能绑定到临时数据

指针和内存
- 指针: 数据或代码在内存中的地址
- 指针变量: 指向的就是内存中的数据或代码，指针只能指向内存，不能指向寄存器或者硬盘，因为寄存器和硬盘没法寻址。
(可能)位于内存中的有
- 一定位于内存中：
  - 局部或者全局变量
  - 创建的对象、字符串常量、
  - 函数形参、函数体本身、new或malloc()分配的内存**等，
  这些内容都可以用&来获取地址，进而用指针指向它们
- 可能位于内存中：
  - 表达式的结果
  - 函数的返回值
  可能会放在内存中，也可能会放在寄存器中。一旦它们被放到了寄存器中，就没法用&获取它们的地址了，也就没法用指针指向它们。一般来说，基本类型的数据通常放在寄存器中，对象、结构体变量通常放在内存中

内存的寻址

实验一：表达式临时结果不可寻址

int n = 100, m = 200;
int *p1 = &(m + n);    //1. m + n 的结果为 300
int *p2 = &(n + 100);  //2. n + 100 的结果为 200
bool *p4 = &(m < n);   //3. m < n 的结果为 false
//1. 2. 3. 表达式的结果放在寄存器中，尝试使用& 获取地址是错误的

实验二：函数返回值不可寻址

int func(){
    int n = 100;
    return n;
}
int *p = &(func());
//函数func的返回值 func() 放在寄存器中，尝试使用& 获取地址是错误的

实验三：常量表达式不可寻址

常量表达式（Constant expression）：如 100、200+34、34.5*23、3+7/3 等不包含变量的表达式

由于不包含变量，没有不稳定因素，所以在编译阶段就能求值。编译器不会分配单独的内存来存储常量表达式的值，而是将常量表达式的值和代码合并到一起，放到虚拟地址空间中的代码区。从汇编的角度看，常量表达式的值就是一个立即数，会被“硬编码”到指令中，不能寻址。

常量表达式的值虽然在内存中，但是没有办法寻址，所以也不能使用&来获取它的地址，更不能用指针指向它

int *p1 = &(100);
int *p2 = &(23 + 45 * 2);

实验四：临时结构体变量可寻址


#include <iostream>
using namespace std;
typedef struct{
    int a;
    int b;
} S;
S operator+(const S &A, const S &B){ //运算符重载
    S C;
    C.a = A.a + B.a;
    C.b = A.b + B.b;
    return C;
}
S func(){
    S a;
    a.a = 100;
    a.b = 200;
    return a;
}

int main(){
    S s1 = {23, 45};
    S s2 = {90, 75};
    S *p1 = &(s1 + s2);
    S *p2 = &(func());
    cout<<p1<<", "<<p2<<endl;
    return 0;
}

运行结果：

0x28ff28, 0x28ff18

引用的非法使用

引用和指针在本质上是一样的，不能绑定到无法寻址的临时数据，并且C++对引用更加严格，在某些编译器下甚至连放在内存中的临时数据都不能绑定。

引用指代临时数据

有如下结论：

在 GCC 下，引用不能指代任何临时数据，不管它保存到哪里；
在 Visual C++ 下，引用只能指代位于内存中（非代码区）的临时数据，不能指代寄存器中的临时数据。

引用作为函数参数(传递临时数据)

当引用作为函数参数时，给它传递临时数据作为实参时是错误的。如下所示：

bool isOdd(int &n){ //用来判断一个数是否是奇数,左值引用作为函数参数
    if(n%2 == 0){
        return false;
    }else{
        return true;
    }
}
int main(){
    int a = 100;
    isOdd(a);  //正确
    isOdd(a + 9);  //错误，尝试将表达式绑定到左值
    isOdd(27);  //错误，尝试将常量表达式绑定到左值
    isOdd(23 + 55);  //错误，尝试将常量表达式绑定到左值
    return 0;
}

isOdd() 函数用来判断一个数是否为奇数，它的参数是引用类型，只能传递变量，不能传递常量或者表达式。

类似这样的函数应该坚持使用值传递，或者右值引用，或者左值常引用。

使用右值引用进行修改

bool isOdd(int &&n){ 
    if(n%2 == 0){
        return false;
    }else{
        return true;
    }
}
//isOdd(a); //无法将右值引用绑定到左值
isOdd(std::move(a));  //正确
isOdd(a + 9);  //正确
isOdd(27);  //正确
isOdd(23 + 55);  //正确

使用左值常引用进行修改 TODO

bool isOdd_const(const int &n){ 
    if(n%2 == 0){
        return false;
    }else{
        return true;
    }
}
isOdd_const(a); //正确
isOdd_const(a + 9);  //正确
isOdd_const(27);  //正确
isOdd_const(23 + 55);  //正确

常(左值)引用为什么可以绑定到临时变量

常引用：无特殊说明的情况下，常引用指的是常左值引用；"常"指的是绑定的变量具有只读性，不可修改。

再来看 isOdd_const() 函数的例子，当将引用n修饰为

const int &n

后，便可以绑定到临时变量。实际上，将常引用绑定到临时数据时，编译器采取了一种妥协机制：编译器会为临时数据创建一个新的、无名的临时变量，并将临时数据放入该临时变量中，然后再将引用绑定到该临时变量。注意，临时变量也是变量，所有的变量都会被分配内存。

那么，为什么编译器为常引用创建临时变量是合理的，而为普通引用创建临时变量不合理呢？可以从下面两方面进行考虑：

对于一般引用，临时数据往往无法寻址，是不能写入的，即使为临时数据创建了一个临时变量，那么修改的也仅仅是临时变量里面的数据，不会影响原来的数据，这样就使得引用所绑定到的数据(临时变量的)和原来的数据(临时数据)不能同步更新，最终产生了两份不同的数据，失去了引用的意义；
对于常引用：不能修改绑定的值，数据只有只读性，为 const 引用创建临时变量反而会使得引用更加灵活和通用。

const 引用与类型转换

更进一步，

给引用添加 const 限定后，不但可以将引用绑定到临时数据，还可以将引用绑定到类型相近的数据

当引用的类型和数据的类型不一致时，如果它们的类型是相近的，并且遵守「数据类型的自动转换」规则，那么编译器就会创建一个临时变量，并将数据赋值给这个临时变量（这时候会发生自动类型转换），然后再将引用绑定到这个临时的变量
比如

int a = 10;
const float &ra = a; //引用的类型和数据的类型不一致,编译器就会创建一个临时变量，并将数据赋值给这个临时变量(这时候会发生自动类型转换）

是合法的。

引用类型的函数形参尽可能使用const

当引用作为函数参数时，如果在函数体内部不会修改引用所绑定的数据，那么请尽量为该引用添加 const 限制。有点如下：

使用 const 可以避免无意中修改数据的编程错误；
使用 const 能让函数接收 const 和非 const 类型的实参，否则将只能接收非 const 类型的实参；
使用 const 引用能够让函数正确生成并使用临时变量。

#include <cstdio>
using namespace std;
double volume(const double &len, const double &width, const double &hei){
    return len*width*2 + len*hei*2 + width*hei*2;
}
int main(){
    int a = 12, b = 3, c = 20;
    double v1 = volume(a, b, c);
    double v2 = volume(10, 20, 30); //接收常量整数，自动类型转换
    double v3 = volume(89.4, 32.7, 19); //接收常量浮点数
    double v4 = volume(a+12.5, b+23.4, 16.78); //接收表达式(右值)
    double v5 = volume(a+b, a+c, b+c); //接收表达式(右值)
    printf("%lf, %lf, %lf, %lf, %lf\n", v1, v2, v3, v4, v5);
    return 0;
}