Go最全C++引用10分钟入门教程_windows 快捷方式 原始 地址 c++，2024年最新面试官不讲武德

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

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
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
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++引用在本质上是什么，它和指针到底有什么区别？


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


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

#include
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
#include
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 是多此一举。


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

int a = 10;
int &r = a;
int &rr = r;

4. 指针和引用的自增（++）自减（–）运算意义不一样。对指针使用 ++ 表示指向下一份数据，对引用使用 ++ 表示它所指代的数据本身加 1；自减（–）也是类似的道理。请看下面的例子：

#include
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++引用不能绑定到临时数据


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


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


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

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
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;
}#include 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++运算符重载]( )》一章中详细讲解。
> 
> 
> 


### 关于常量表达式


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


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



> 
> 关于虚拟地址空间的分区，我们已在《[Linux下C语言程序的内存布局]( )》一节中讲到。
> 
> 
> 


总起来说，常量表达式的值虽然在内存中，但是没有办法寻址，所以也不能使用`&`来获取它的地址，更不能用指针指向它。下面的代码是错误的，它证明了不能用`&`来获取常量表达式的地址：

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

### 引用也不能指代临时数据


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


下面的代码中，我们将引用绑定到了临时数据：

typedef struct{
int a;
int b;
} S;
int func_int(){
int n = 100;
return n;
}
S func_s(){
S a;
a.a = 100;
a.b = 200;
return a;
}
//这里用到了一点新知识，叫做运算符重载，我们会在《运算符重载》一章中详细讲解
S operator+(const S &A, const S &B){
S C;
C.a = A.a + B.a;
C.b = A.b + B.b;
return C;
}
int main(){
//下面的代码在GCC和Visual C++下都是错误的
int m = 100, n = 36;
int &r1 = m + n;
int &r2 = m + 28;
int &r3 = 12 * 3;
int &r4 = 50;
int &r5 = func_int();

//下面的代码在GCC下是错误的，在Visual C++下是正确的
S s1 = {23, 45};
S s2 = {90, 75};
S &r6 = func_s();
S &r7 = s1 + s2;
return 0;

}

第 28~33 行代码在 GCC 和 Visual C++ 下都不能编译通过，第 38~39 行代码在 Visual C++ 下能够编译通过，但是在 GCC 下编译失败。这说明：


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


### 引用作为函数参数


当引用作为函数参数时，有时候很容易给它传递临时数据。下面的 isOdd() 函数用来判断一个数是否是奇数：

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;
}
}
int main(){
int a = 100;
isOdd(a); //正确
isOdd(a + 9); //正确
isOdd(27); //正确
isOdd(23 + 55); //正确
return 0;
}

## 编译器会为const引用创建临时变量


上节我们讲到，引用不能绑定到临时数据，这在大多数情况下是正确的，但是当使用 const 关键字对引用加以限定后，引用就可以绑定到临时数据了。下面的代码演示了引用和 const 这一对神奇的组合：

typedef struct{
int a;
int b;
} S;
int func_int(){
int n = 100;
return n;
}
S func_s(){
S a;
a.a = 100;
a.b = 200;
return a;
}
S operator+(const S &A, const S &B){
S C;
C.a = A.a + B.a;
C.b = A.b + B.b;
return C;
}
int main(){
int m = 100, n = 36;
const int &r1 = m + n;
const int &r2 = m + 28;
const int &r3 = 12 * 3;
const int &r4 = 50;
const int &r5 = func_int();
S s1 = {23, 45};
S s2 = {90, 75};
const S &r6 = func_s();
const S &r7 = s1 + s2;
return 0;
}

这段代码在 GCC 和 Visual C++ 下都能够编译通过，这是因为将常引用绑定到临时数据时，编译器采取了一种妥协机制：编译器会为临时数据创建一个新的、无名的临时变量，并将临时数据放入该临时变量中，然后再将引用绑定到该临时变量。注意，临时变量也是变量，所有的变量都会被分配内存。


为什么编译器为常引用创建临时变量是合理的，而为普通引用创建临时变量就不合理呢？




![img](https://img-blog.csdnimg.cn/img_convert/427cc8d8b574d8683fb77629408b163b.png)
![img](https://img-blog.csdnimg.cn/img_convert/f0445ba0271eedd7811277353668dfb1.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

90, 75};
    const S &r6 = func_s();
    const S &r7 = s1 + s2;
    return 0;
}

这段代码在 GCC 和 Visual C++ 下都能够编译通过，这是因为将常引用绑定到临时数据时，编译器采取了一种妥协机制：编译器会为临时数据创建一个新的、无名的临时变量，并将临时数据放入该临时变量中，然后再将引用绑定到该临时变量。注意，临时变量也是变量，所有的变量都会被分配内存。

为什么编译器为常引用创建临时变量是合理的，而为普通引用创建临时变量就不合理呢？

[外链图片转存中…(img-PI9SGCgm-1715502332765)]
[外链图片转存中…(img-h4z7GUI8-1715502332765)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！