【学习QT必备的C++基础】C++引用精讲

img
img

既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上物联网嵌入式知识点,真正体系化!

由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频,并且后续会持续更新

需要这些体系化资料的朋友,可以加我V获取:vip1024c (备注嵌入式)

如果你需要这些资料,可以戳这里获取

注意,引用在定义时需要添加&,在使用时不能添加&,使用时添加&表示取地址。如上面代码所示,第 6 行中的&表示引用,第 8 行中的&表示取地址。除了这两种用法,&还可以表示位运算中的与运算。

由于引用 r 和原始变量 a 都是指向同一地址,所以通过引用也可以修改原始变量中所存储的数据,请看下面的例子:

#include <iostream>
using namespace std;
int main() {
    int a = 99;
    int &r = a;
    r = 47;
    cout << a << ", " << r << endl;
    return 0;
}

运行结果:
47, 47

最终程序输出两个 47,可见原始变量 a 的值已经被引用变量 r 所修改。

如果读者不希望通过引用来修改原始的数据,那么可以在定义时添加 const 限制,形式为:

const type &name = value;

也可以是:

type const &name = value;

这种引用方式为常引用

C++引用作为函数参数

在定义或声明函数时,我们可以将函数的形参指定为引用的形式,这样在调用函数时就会将实参和形参绑定在一起,让它们都指代同一份数据。如此一来,如果在函数体中修改了形参的数据,那么实参的数据也会被修改,从而拥有“在函数内部影响函数外部数据”的效果。

至于实参和形参是如何绑定的,我们将在下节《C++引用在本质上是什么,它和指针到底有什么区别?》中讲解,届时我们会一针见血地阐明引用的本质。

一个能够展现按引用传参的优势的例子就是交换两个数的值,请看下面的代码:

#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

本例演示了三种交换变量的值的方法:

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

从以上代码的编写中可以发现,按引用传参在使用形式上比指针更加直观。在以后的 C++ 编程中,我鼓励读者大量使用引用,它一般可以代替指针(当然指针在C++中也不可或缺),C++ 标准库也是这样做的。

C++引用作为函数返回值

引用除了可以作为函数形参,还可以作为函数返回值,请看下面的例子:

#include <iostream>
using namespace std;
int &plus10(int &r) {
    r += 10;
    return r;
}
int main() {
    int num1 = 10;
    int num2 = plus10(num1);
    cout << num1 << " " << num2 << endl;
    return 0;
}

运行结果:
20 20

在将引用作为函数返回值时应该注意一个小问题,就是不能返回局部数据(例如局部变量、局部对象、局部数组等)的引用,因为当函数调用完成后局部数据就会被销毁,有可能在下次使用时数据就不存在了,C++ 编译器检测到该行为时也会给出警告。

更改上面的例子,让 plus10() 返回一个局部数据的引用:

#include <iostream>
using namespace std;
int &plus10(int &r) {
    int m = r + 10;
    return m;  //返回局部数据的引用
}
int main() {
    int num1 = 10;
    int num2 = plus10(num1);
    cout << num2 << endl;
    int &num3 = plus10(num1);
    int &num4 = plus10(num3);
    cout << num3 << " " << num4 << endl;
    return 0;
}

在 Visual Studio 下的运行结果:

20
-858993450 -858993450

GCC 下的运行结果:

20
30 30

在 C-Free 下的运行结果:

20
30 0

而我们期望的运行结果是:

20
20 30

plus10() 返回一个对局部变量 m 的引用,这是导致运行结果非常怪异的根源,因为函数是在栈上运行的,并且运行结束后会放弃对所有局部数据的管理权,后面的函数调用会覆盖前面函数的局部数据。本例中,第二次调用 plus10() 会覆盖第一次调用 plus10() 所产生的局部数据,第三次调用 plus10() 会覆盖第二次调用 plus10() 所产生的局部数据。

关于函数调用的内部实现,我已在《C语言内存精讲》专题中讲到。

C++引用在本质上是什么,它和指针到底有什么区别?

已剪辑自: http://c.biancheng.net/view/vip_2252.html

通过上节的讲解,相信各位读者对引用都有了一个概念上的认识,能够简单地使用引用编程了,但又感觉糊里糊涂,不明白它到底是什么,它和指针有点相似,但又不是一个东西。

首先来回顾一下上节的例子:

#include <iostream>
using namespace std;
int main(){
    int a = 99;
    int &r = a;
    cout<<a<<", "<<r<<endl;
    cout<<&a<<", "<<&r<<endl;
    return 0;
}

运行结果:
99, 99
0x28ff44, 0x28ff44

我们知道,变量是要占用内存的,虽然我们称 r 为变量,但是通过&r获取到的却不是 r 的地址,而是 a 的地址,这会让我们觉得 r 这个变量不占用独立的内存,它和 a 指代的是同一份内存。

请读者再继续看下面的例子:

#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;  //输出A类型的大小
    cout<<hex<<showbase<<*((int*)a + 1)<<endl;  //输出r本身的内容
    cout<<&num<<endl;  //输出num变量的地址
    return 0;
}

运行结果:
8
0x442000
0x442000

成员变量 r 是 private 属性的,不能直接通过对象来访问,但是借助强大的指针和类型转换,我们依然可以得到它的内容,只不过这种方法有点蹩脚,我们将在《突破访问权限的限制(C++ Hack)》一节中详细阐述,读者暂时不必理解,只要知道第 20 行代码是用来输出 r 本身的内容的即可。

第 20 行代码中,hex表示以十六进制输出,showbase表示添加十六进制前缀0x

从运行结果可以看出:

  • 成员变量 r 是占用内存的,如果不占用的话,sizeof(A)的结果应该为 4。
  • r 存储的内容是0x442000,也即变量 num 的地址。

这说明 r 的实现和指针非常类似。如果将 r 定义为int *类型的指针,并在构造函数中让它指向 num,那么 r 占用的内存也是 4 个字节,存储的内容也是 num 的地址。

其实引用只是对指针进行了简单的封装,它的底层依然是通过指针实现的,引用占用的内存和指针占用的内存长度一样,在 32 位环境下是 4 个字节,在 64 位环境下是 8 个字节,之所以不能获取引用的地址,是因为编译器进行了内部转换。以下面的语句为例:

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

编译时会被转换成如下的形式:

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

使用&r取地址时,编译器会对代码进行隐式的转换,使得代码输出的是 r 的内容(a 的地址),而不是 r 的地址,这就是为什么获取不到引用变量的地址的原因。也就是说,不是变量 r 不占用内存,而是编译器不让获取它的地址。

当引用作为函数参数时,也会有类似的转换。以下面的代码为例:

//定义函数
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);

引用虽然是基于指针实现的,但它比指针更加易用,从上面的两个例子也可以看出来,通过指针获取数据时需要加*,书写麻烦,而引用不需要,它和普通变量的使用方式一样。

C++ 的发明人 Bjarne Stroustrup 也说过,他在 C++ 中引入引用的直接目的是为了让代码的书写更加漂亮,尤其是在运算符重载中,不借助引用有时候会使得运算符的使用很麻烦。

引用和指针的其他区别

  1. 引用必须在定义时初始化,并且以后也要从一而终,不能再指向其他数据;而指针没有这个限制,指针在定义时不必赋值,以后也能指向任意数据。
  2. 可以有 const 指针,但是没有 const 引用。也就是说,引用变量不能定义为下面的形式:
int a = 20;
int & const r = a;

因为 r 本来就不能改变指向,加上 const 是多此一举。

  1. 指针可以有多级,但是引用只能有一级,例如,int **p是合法的,而int &&r是不合法的。如果希望定义一个引用变量来指代另外一个引用变量,那么也只需要加一个&,如下所示:
int a = 10;
int &r = a;
int &rr = r;

  1. 指针和引用的自增(++)自减(–)运算意义不一样。对指针使用 ++ 表示指向下一份数据,对引用使用 ++ 表示它所指代的数据本身加 1;自减(–)也是类似的道理。请看下面的例子:
#include <iostream>
using namespace std;
int main (){
    int a = 10;
    int &r = a;
    r++;
    cout<<r<<endl;
   
    int arr[2] = { 27, 84 };
    int *p = arr;
    p++;
    cout<<*p<<endl;
    return 0;
}

运行结果:
11
84

C++引用不能绑定到临时数据

已剪辑自: http://c.biancheng.net/view/vip_2253.html

我们知道,指针就是数据或代码在内存中的地址,指针变量指向的就是内存中的数据或代码。这里有一个关键词需要强调,就是内存,指针只能指向内存,不能指向寄存器或者硬盘,因为寄存器和硬盘没法寻址。

其实 C++ 代码中的大部分内容都是放在内存中的,例如定义的变量、创建的对象、字符串常量、函数形参、函数体本身、newmalloc()分配的内存等,这些内容都可以用&来获取地址,进而用指针指向它们。除此之外,还有一些我们平时不太留意的临时数据,例如表达式的结果、函数的返回值等,它们可能会放在内存中,也可能会放在寄存器中。一旦它们被放到了寄存器中,就没法用&获取它们的地址了,也就没法用指针指向它们了。

下面的代码演示了表达式所产生的临时结果:

int n = 100, m = 200;
int *p1 = &(m + n);    //m + n 的结果为 300
int *p2 = &(n + 100);  //n + 100 的结果为 200
bool *p4 = &(m < n);   //m < n 的结果为 false

这些表达式的结果都会被放到寄存器中,尝试用&获取它们的地址都是错误的。

下面的代码演示了函数返回值所产生的临时结果:

int func(){
    int n = 100;
    return n;
}
int *p = &(func());

func() 的返回值 100 也会被放到寄存器中,也没法用&获取它的地址。

什么样的临时数据会放到寄存器中

寄存器离 CPU 近,并且速度比内存快,将临时数据放到寄存器是为了加快程序运行。但是寄存器的数量是非常有限的,容纳不下较大的数据,所以只能将较小的临时数据放在寄存器中。int、double、bool、char 等基本类型的数据往往不超过 8 个字节,用一两个寄存器就能存储,所以这些类型的临时数据通常会放到寄存器中;而对象、结构体变量是自定义类型的数据,大小不可预测,所以这些类型的临时数据通常会放到内存中。

下面的代码是正确的,它证明了结构体类型的临时数据会被放到内存中:

#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 第10行代码用到了运算符重载,我们将在《C++运算符重载》一章中详细讲解。

关于常量表达式

img
img

既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上物联网嵌入式知识点,真正体系化!

由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频,并且后续会持续更新

需要这些体系化资料的朋友,可以加我V获取:vip1024c (备注嵌入式)

如果你需要这些资料,可以戳这里获取

S *p2 = &(func());
cout<<p1<<", "<<p2<<endl;
return 0;

}


运行结果:  
 0x28ff28, 0x28ff18 第10行代码用到了运算符重载,我们将在《[C++运算符重载]( )》一章中详细讲解。


### 关于常量表达式



[外链图片转存中...(img-kjfhI4R1-1715798001707)]
[外链图片转存中...(img-bjguQAEx-1715798001708)]

**既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上物联网嵌入式知识点,真正体系化!**

**由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频,并且后续会持续更新**

**需要这些体系化资料的朋友,可以加我V获取:vip1024c (备注嵌入式)**

**[如果你需要这些资料,可以戳这里获取](https://bbs.csdn.net/topics/618679757)**

  • 28
    点赞
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值