指针和引用

最新推荐文章于 2024-11-07 04:45:00 发布
原创 最新推荐文章于 2024-11-07 04:45:00 发布 · 682 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#pointers #reference #编译器 #汇编 #iostream #object

本文深入探讨了C与C++中指针和引用的区别与联系，特别是从汇编层面剖析了两者的工作原理，并解释了在实际编程中的一些常见行为差异。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 

The most important difference between  pointers in C and those in C++ is that C++ is a more strongly typed language.This stands out where void * is concerne.

代码:

bird * b;

rock * r;

void * v;

v=r;

b=v;//这两个赋值在C编译器通过,在C++编译器不通过

void * 在C中表示指向任意的类型. 在C++中表示指向void类型.

 

A reference (&) is like a const pointer that is automatically dereferenced.There are certain rules when using references.

1.A reference must be initialized when it is created.(Pointers can be intialized at any time).

2.Once a reference is initialized to an object,it can not be changed to refer to another object.

(Pointers can  be pointed to another object at any time).

3.you can not have NULL reference.

把引用认为是一个对象的别名,上面规则就好理解了.

下面看一段代码的汇编来理解

#include <iostream>
using namespace std;

int* f1(int * px)
{
  (*px)++;
  return px;

}

int& g1(int & rx)
{
 rx++;
 return rx;
}

int main()
{
 int a=1;
   f1(&a);
   g1(a);
   return 0;
}

 

  1. 6:
  2. 17:   int main()
  3. 18:   {
  4. 004012E0   push        ebp
  5. 004012E1   mov         ebp,esp
  6. 004012E3   sub         esp,44h
  7. 004012E6   push        ebx
  8. 004012E7   push        esi
  9. 004012E8   push        edi
  10. 004012E9   lea         edi,[ebp-44h]
  11. 004012EC   mov         ecx,11h
  12. 004012F1   mov         eax,0CCCCCCCCh
  13. 004012F6   rep stos    dword ptr [edi]
  14. 19:       int a=1;
  15. 004012F8   mov         dword ptr [ebp-4],1//SS:[ebp-4]存放的是a变量的值
  16. 20:      f1(&a);
  17. 004012FF   lea         eax,[ebp-4]//eax存的是a变量的地址
  19. 00401302   push        eax//函数的参数入栈
  20. 00401303   call        @ILT+10(f1) (0040100f)//跟进去
  22. /*
  23. 00401308   add         esp,4
  24. 21:      g1(a);
  25. 0040130B   lea         ecx,[ebp-4]
  26. 0040130E   push        ecx
  27. 0040130F   call        @ILT+20(g1) (00401019)
  28. 00401314   add         esp,4
  29. 22:      return 0;
  30. 00401317   xor         eax,eax
  31. 23:   }
  32. 00401319   pop         edi
  33. 0040131A   pop         esi
  34. 0040131B   pop         ebx
  35. 0040131C   add         esp,44h
  36. 0040131F   cmp         ebp,esp
  37. 00401321   call        __chkesp (004081f0)
  38. 00401326   mov         esp,ebp
  39. 00401328   pop         ebp
  40. 00401329   ret
  41. */
  42. @ILT+10(?f1@@YAPAHPAH@Z):
  43. 0040100F   jmp         f1 (00401260)
  45. 4:    int* f1(int * px)
  46. 5:    {
  47. 00401260   push        ebp
  48. 00401261   mov         ebp,esp
  49. 00401263   sub         esp,40h
  50. 00401266   push        ebx
  51. 00401267   push        esi
  52. 00401268   push        edi
  53. 00401269   lea         edi,[ebp-40h]
  54. 0040126C   mov         ecx,10h
  55. 00401271   mov         eax,0CCCCCCCCh
  56. 00401276   rep stos    dword ptr [edi]
  57. 6:      (*px)++;
  58. 00401278   mov         eax,dword ptr [ebp+8]
  59. //注意这句 ebp+8指的内存里存的是先前eax的值,即a的地址.
  60. //所以操作后 eax是a的地址.
  61. 0040127B   mov         ecx,dword ptr [eax]//ecx=*px
  62. 0040127D   add         ecx,1
  63. 00401280   mov         edx,dword ptr [ebp+8]//edx=&px注意
  64. 00401283   mov         dword ptr [edx],ecx//这句改变了a的值,
  65. 7:      return px;
  66. 00401285   mov         eax,dword ptr [ebp+8]
  67. 8:
  68. 9:    }
  69. 00401288   pop         edi
  70. 00401289   pop         esi
  71. 0040128A   pop         ebx
  72. 0040128B   mov         esp,ebp
  73. 0040128D   pop         ebp
  74. 0040128E   ret
  75. 返回到main函数
  76. 00401308   add         esp,4 //移除函数参数
  77. 21:      g1(a);
  78. 0040130B   lea         ecx,[ebp-4]//注意和前面的指针调用一模一样
  79. 0040130E   push        ecx//函数参数入栈
  80. 0040130F   call        @ILT+20(g1) (00401019)跟进去
  82. @ILT+20(?g1@@YAAAHAAH@Z):
  83. 00401019   jmp         g1 (004012a0)
  85.  int& g1(int & rx)
  86. 12:   {
  87. 004012A0   push        ebp
  88. 004012A1   mov         ebp,esp
  89. 004012A3   sub         esp,40h
  90. 004012A6   push        ebx
  91. 004012A7   push        esi
  92. 004012A8   push        edi
  93. 004012A9   lea         edi,[ebp-40h]
  94. 004012AC   mov         ecx,10h
  95. 004012B1   mov         eax,0CCCCCCCCh
  96. 004012B6   rep stos    dword ptr [edi]
  97. 13:       rx++;
  98. //我们来和指针做个比较,代码一模一样
  99. /*
  100. 6:      (*px)++;
  101. 00401278   mov         eax,dword ptr [ebp+8]
  102. //注意这句 ebp+8指的内存里存的是先前eax的值,即a的地址.
  103. //所以操作后 eax是a的地址.
  104. 0040127B   mov         ecx,dword ptr [eax]//ecx=*px
  105. 0040127D   add         ecx,1
  106. 00401280   mov         edx,dword ptr [ebp+8]//edx=&px注意
  107. 00401283   mov         dword ptr [edx],ecx//这句改变了a的值,
  108. 7:      return px;
  109. 00401285   mov         eax,dword ptr [ebp+8]
  111. */
  112. 004012B8   mov         eax,dword ptr [ebp+8]
  113. 004012BB   mov         ecx,dword ptr [eax]
  114. 004012BD   add         ecx,1
  115. 004012C0   mov         edx,dword ptr [ebp+8]
  116. 004012C3   mov         dword ptr [edx],ecx
  117. 14:       return rx;
  118. 004012C5   mov         eax,dword ptr [ebp+8]
  119. 15:   }
  120. 004012C8   pop         edi
  121. 004012C9   pop         esi
  122. 004012CA   pop         ebx
  123. 004012CB   mov         esp,ebp
  124. 004012CD   pop         ebp
  125. 004012CE   ret
  126. 返回到main函数
  127. 00401314   add         esp,4//移除函数参数
  128. 22:      return 0;
  129. 00401317   xor         eax,eax
  130. 23:   }
  131. 00401319   pop         edi
  132. 0040131A   pop         esi
  133. 0040131B   pop         ebx
  134. 0040131C   add         esp,44h
  135. 0040131F   cmp         ebp,esp
  136. 00401321   call        __chkesp (004081f0)也跟进去看看
  138. 00401326   mov         esp,ebp
  139. 00401328   pop         ebp
  140. 00401329   ret
  144. _chkesp:
  145. 004081F0   jne         __chkesp+3 (004081f3)//不相等就转去处理异常了
  146. 004081F2   ret
  147. 004081F3   push        ebp
  148. 004081F4   mov         ebp,esp
  149. 004081F6   sub         esp,0
  150. 004081F9   push        eax
  151. 004081FA   push        edx
  152. 004081FB   push        ebx
  153. 004081FC   push        esi
  154. 004081FD   push        edi
  155. 004081FE   push        offset string "The value of ESP was not properl"... (004312b4)
  156. 00408203   push        offset string "" (004311b4)
  157. 00408208   push        2Ah
  158. 0040820A   push        offset string "i386//chkesp.c" (004312a4)
  159. 0040820F   push        1
  160. 00408211   call        _CrtDbgReport (0040ca70)
  161. 00408216   add         esp,14h
  162. 00408219   cmp         eax,1
  163. 0040821C   jne         __chkesp+2Fh (0040821f)
  164. 0040821E   int         3
  165. 0040821F   pop         edi
  166. 00408220   pop         esi
  167. 00408221   pop         ebx
  168. 00408222   pop         edx
  169. 00408223   pop         eax
  170. 00408224   mov         esp,ebp
  171. 00408226   pop         ebp
  172. 00408227   ret

总结:从此例汇编层来看,引用和指针是没有区别的.

 

那我就有一个地方想不明白了

#include <iostream>

using namespace std;

int main()

{

  int a=3;

  int *pa=&a;

  int &  ra=a;

 cout<<&pa<<endl;

cout<<&ra<<endl;

cout<<&a<<endl;

return 0;

}

结果:

0012FF78

0012FF7C

0012FF7C

这两个输出为什么不同?

继续跟踪汇编


1:    #include <iostream>
2:
3:    using namespace std;
4:
5:    int main()
6:
7:    {
00401250   push        ebp
00401251   mov         ebp,esp
00401253   sub         esp,54h//(54h-40h)/04h=20/4=5
00401256   push        ebx
00401257   push        esi
00401258   push        edi
00401259   lea         edi,[ebp-54h]
0040125C   mov         ecx,15h
00401261   mov         eax,0CCCCCCCCh
00401266   rep stos    dword ptr [edi]
8:
9:      int a=3;
00401268   mov         dword ptr [ebp-4],3//第一个局部变量a
10:
11:     int *pa=&a;
0040126F   lea         eax,[ebp-4]
00401272   mov         dword ptr [ebp-8],eax //第二个局部变量pa
12:
13:     int &  ra=a;
00401275   lea         ecx,[ebp-4]
00401278   mov         dword ptr [ebp-0Ch],ecx // 第三个局部变量ra


14:     int * pb=&a;
0040127B   lea         edx,[ebp-4]
0040127E   mov         dword ptr [ebp-10h],edx//第四个局部变量pb
15:           pb=&ra;
00401281   mov         eax,dword ptr [ebp-0Ch]
00401284   mov         dword ptr [ebp-10h],eax


16:     int ** pc=&pa;
00401287   lea         ecx,[ebp-8]//第五个局部变量
0040128A   mov         dword ptr [ebp-14h],ecx
17:
18:
19:   return 0;
0040128D   xor         eax,eax
20:
21:   }
0040128F   pop         edi
00401290   pop         esi
00401291   pop         ebx
00401292   mov         esp,ebp
00401294   pop         ebp
00401295   ret
总结:

搞明白了,引用其实就是一个指针,只是编译器会自动对它解析,并进行代码优化.

也就是 A reference (&) is like a const pointer that is automatically dereferenced.

所以上面的代码

 

cout<<&ra<<endl;编译器对它做了转化  cout<< &(*ra)<<endl;

C++ 指针和引用引用详解
qq_35320456的博客
03-10 2715
C++ 指针和引用引用详解
C++常量 运算符
weixin_30458043的博客
02-26 295
\n 换行 光标移到下一行 \0 空值 \t 水平制表符 \r 回车 光标回到本行开头 \b 退格 光标退一格 \f 换页符 光标移到下一页开始 \ddd 任意字符 \xh...
c++试题
weixin_43293451的博客
10-08 284
#include<iostream> using namespace std; int main() { int i, a[4] = {2,3,4,5},*pa; pa = a; for (i = 0; i < 4;i++) { *pa *= *pa;//元素的平方复制给各元素 printf("a[%d] = %d\n",i,a[i] ); pa++; }...
【从C到C++】------- C++的引用
big_C的博客
11-19 230
4.C++新增的引用 1、引用介绍 (1)引用的经典案例：实现swap函数实战 #include <iostream> using namespace std; void swap1(int a, int b); void swap2(int *pa, int *pb); void swap3(int &amp;pa, int &amp;pb); int main(void) { int x = 4, y = 6; swap1(x, y); swap2(&amp;x, &a.
C++中参数传递方式讨论
人生如旅
07-31 859
众所周知，在C＋＋中调用函数时有三种参数传递方式： （1）传值调用； （2）传址调用（传指针）； （3）引用传递； 实际上，还有一种参数传递方式，就是全局变量传递方式。这里的“全局”变量并不见得就是真正的全局的，所有代码都可以直接访问的，只要这个变量
c++知识
随手记
07-31 399
指针的引用 //第一种情况 #include usingnamespace std;   intmain() {    int a = 1;    int b = 2;    int *tmp = &a;    int *p = tmp;      p = &b;    *p = 5;      cout"a::"aendl       "b::"bendl
指针和引用的区别
安安的博客
05-16 1万+
前言 指针和引用在形式上很好区别，在C++中相比于指针我们更喜欢使用引用，但是它们的使用场景又极其类似，它们都能直接引用对象，对对象进行处理，那么究竟为什么会引入？什么时候使用指针？什么时候使用引用？这两者实在容易混淆，在此我详细介绍一下指针和引用。 指针和引用的定义 维基百科中这样解释 指针： 在计算机科学中，指针（英语：Pointer），是编程语言中的一类数据类型及其对象或变量，用来表示或存储一个存储器地址，这个地址的值直接指向（points to）存在该地址的对象的值。 引用： 在C++编程语言中，引
【C++】指针和引用
Guiat的博客
11-07 961
期待您的一键三连！欢迎指正！
两个数交换 指针实现
c++短期爱好者
07-29 464
#include&amp;lt;iostream&amp;gt; using namespace std; #include&amp;lt;cstdio&amp;gt; int main() {     int a,b;     int * pa=&amp;amp;a;     int * pb=&amp;amp;b;     int * t;     cin&amp;gt;&amp;gt;a&amp;gt;&amp;gt;b;     t=pa;     pa=pb;   ...
指针变量引用
alike_meng的博客
01-01 319
#include<iostream> using namespace std; int main() { int a = 1; int b = 10; int* p = &amp;a; //指针变量p指向a int* &amp;pa = p; //pa是p的指针引用 (*pa)++; //pa指针指向的内容+1，pa是p的引用，p指向的内...
关于指针和引用
Cgsyuan
08-14 622
1.异同点 引用与指针都是复合类型(compound type)，建立在已存在类型的基础上 引用是对对象的绑定，是对象的别名，并不是具体的对象；指针指向某一对象，指针本身就是一个对象 引用在定义时必须初始化，且只能绑定一个对象不能修改；指针在定义时不要求初始化，且指针可以更改指向的对象 2.初始化 引用的初始化： View Code 指针的初始化：
C++初阶学习3
qq_41921349的博客
08-27 266
#include<iostream> using namespace std; int main() { int a[10] = { 1, 3, 4, 5, 7, 8, 9, 1, 10, 2 }; for (auto &amp;i : a) { i *= 2; cout << i << endl;//用引用来接数组中的每一个元素是可以改变的 ...
按书名字母顺序排序 c 语言,2020春 C/C++程序设计(高枚)-中国大学mooc-题库零氪
weixin_29163857的博客
05-17 2507
第1讲 C/C++程序设计入门第1讲单元测验1、以下________是C/C++合法的标识符。A、char2B、@xC、intD、7Bw2、下面的程序，对于输入：2 9 15，输出的结果是________。 #include "iostream" using namespace std; int main() { int a; int b; cout<>a>>b; cout...
c++程序设计基础（第五版）（上） 习题与解答
热门推荐
bueke的博客
09-09 11万+
习题与解答 C++程序设计基础（第5版）（上） 习题与解答 第1章练习题 同步练习1.1 一、选择题 1．一个最简单的C++程序，可以只有一个（ ）。 （A）库函数 （B）自定义函数 （C）main函数 （D）空函数 2．函数名是（ ），用于识别和调用函数。 （A）关键字 （B）标识符 （C）常数 （D）语句 3．用C++语言编写的源程序要成为目标程序必须要经过（ ）...
_snprintf_s()函数的正确用法
zhangmiaoping23的专栏
07-21 4万+
_snprintf_s()函数的n代表最多复制多少个字符，函数名尾部_s表示检测缓冲区溢出，微软特有的检测。 正确用法如下： char szTable[27] = "abcdefghijklmnopqrstuvwxyz"; char szBuffer[10] = { 0 }; //将会崩溃，因为会发生缓冲区溢出 //_snprintf_s(szBuffer, sizeof(szBu
生成浮点数的随机函数
zhangmiaoping23的专栏
02-18 8124
今天在群里和一位朋友讨论了浮点数的随机函数实现.以下为代码和思路. //为了扣题和便于理解，我没用一些C++高阶的技巧，完全按照题目一步一步走,所以显得麻烦点#include #include #include #define MAX_RANDOM 1000    //这个是产生随机数的最大值，但是取浮点数，所以要除去的#define NUM 2500double ra
c++ const 转非const
zhangmiaoping23的专栏
12-30 5202
#include <iostream> #include <stdio.h> using namespace std; struct DexHeader{ int off; }; int main() { struct DexHeader dexHeader; dexHeader.off = 3; const DexHeader* lpDexHeader = &...
密码对比
zhangmiaoping23的专栏
03-21 3105
C程序简单密码对比验证程序: //逐字符匹配密码#include #include #define PASSWORD_SIZE 100#define PASSWORD "myGoodpassword/n"int main(){ //记录鉴定失败次数的订数器 int count=0; //用于存放输入的密码符的缓冲区 char buff[PASSWORD_SIZE]; //鉴定操作主循环
C++指针和引用
最新发布
03-25
<think>嗯，用户想了解C++中指针和引用的区别和使用场景。我先回忆一下自己学过的知识。指针和引用都是用来间接访问变量的，但它们的语法和用途有所不同。首先，指针是一个变量，存储的是另一个变量的内存地址，而引用是变量的别名，必须在声明时初始化，之后不能改变指向。比如，引用一旦指向某个变量，就不能再指向其他变量了，而指针可以重新赋值指向不同的地址。 然后，使用场景方面，指针更灵活，可以指向nullptr，这在某些情况下很有用，比如函数参数可选的时候。但引用必须绑定到一个对象，所以不能为空。另外，引用在函数参数传递时更简洁，不需要取地址操作，比如swap函数用引用参数的话，调用时直接传变量，而用指针的话需要取地址符号&amp;。 不过用户可能想知道更具体的区别，比如内存管理上的不同。指针需要手动管理，可能引发内存泄漏或野指针的问题，而引用因为必须初始化且不能重新绑定，相对安全一些。比如在函数参数传递时，使用引用可以避免指针的解引用操作，代码更易读。 还有，用户提供的引用资料里提到，swap函数的不同实现方式，用指针和引用都能达到交换变量的目的。这说明在函数需要修改外部变量时，引用和指针都可以用，但引用更简洁。另外，二级指针的例子，比如用指针的指针来修改指针的指向，这种情况下引用可能无法替代，必须用指针。 可能用户还会混淆引用的底层实现，其实引用在底层通常也是通过指针实现的，但语法上更安全。此外，操作符重载和函数返回时，引用可能更合适，比如返回函数内部静态变量或动态分配的内存时，可以用引用避免拷贝。 用户可能没有问，但需要补充的是，引用的不可变性，比如不能有空引用，必须在声明时初始化，而指针可以是nullptr或者未初始化的，这也是使用指针需要注意的地方。还有，在容器中存储元素时，比如STL容器，通常使用指针而不是引用，因为引用不能重新赋值，而容器可能需要改变元素的位置或值。 总结一下，回答应该包括定义、初始化、是否可为空、操作方式、内存管理、使用场景等方面的对比，以及具体的例子说明两者的区别。同时，需要结合用户提供的引用资料中的例子，比如swap函数的不同实现，二级指针的使用，来具体说明指针和引用的适用情况。</think>### C++ 指针与引用的区别及使用场景 #### 一、基本概念与核心区别 1. **定义与初始化** - **指针**：存储变量内存地址的变量，可独立存在且允许未初始化（但存在野指针风险）。例如： ```cpp int* p; // 未初始化，可能指向无效地址 ``` - **引用**：是变量的别名，**必须初始化**且不可重新绑定其他对象。例如： ```cpp int x = 10; int&amp; ref = x; // 正确 int&amp; ref2; // 错误！引用必须初始化 ``` 2. **是否可为空** - 指针可赋值为 `nullptr` 表示空值，例如： ```cpp int* p = nullptr; // 合法 ``` - 引用必须绑定有效对象，**不可为空**，例如以下代码会编译错误： ```cpp int&amp; ref = nullptr; // 非法！ ``` 3. **操作方式** - 指针需要通过解引用操作符 `*` 访问目标值，例如： ```cpp int x = 10; int* p = &amp;x; cout << *p; // 输出10 ``` - 引用直接像普通变量一样使用，例如： ```cpp int&amp; ref = x; cout << ref; // 输出10 ``` #### 二、使用场景对比 1. **函数参数传递** - **指针**：需显式传递地址，适合需要修改原始值或处理可选参数的场景。例如： ```cpp void modify(int* ptr) { if (ptr) *ptr = 20; // 检查指针是否有效 } ``` - **引用**：语法简洁，无需取地址，适合强制要求有效参数的场景。例如： ```cpp void swap(int&amp; a, int&amp; b) { // 引用参数直接操作原变量 int tmp = a; a = b; b = tmp; } ``` 2. **动态内存管理** - **指针**：必须用于动态内存分配（如 `new` 和 `delete`），例如： ```cpp int* arr = new int[10]; delete[] arr; ``` - **引用**：不能直接管理动态内存，但可绑定到动态分配的对象： ```cpp int* p = new int(5); int&amp; ref = *p; // 合法，但需手动释放内存 ``` 3. **多级间接访问** - **指针**：支持多级指针（如二级指针 `int**`），用于修改指针的指向。例如： ```cpp void redirect(int** pp) { *pp = new int(100); } // 修改一级指针的地址[^3] ``` - **引用**：可通过引用传递指针，但无法直接替代多级指针的功能。 4. **返回值优化** - **引用**：常用于返回函数内部静态变量或链式操作，避免拷贝开销。例如： ```cpp string&amp; getGlobalString() { static string s = "hello"; return s; // 返回引用避免复制 } ``` - **指针**：需注意返回局部变量的指针会导致未定义行为。 #### 三、性能与安全性 - **性能**：引用通常由编译器实现为指针，两者效率相同[^1]。 - **安全性**：引用更安全（不可为空且无需解引用），而指针需手动检查有效性。 #### 四、典型示例对比 1. **交换函数实现** - 指针版本： ```cpp void swap(int* a, int* b) { int tmp = *a; *a = *b; *b = tmp; } // 调用方式：swap(&amp;i, &amp;j); ``` - 引用版本： ```cpp void swap(int&amp; a, int&amp; b) { int tmp = a; a = b; b = tmp; } // 调用方式：swap(i, j); // 更简洁[^4] ``` #### 五、总结 | **特性** | **指针** | **引用** | |----------------|----------------------------------|----------------------------------| | 初始化 | 可延迟初始化 | 必须初始化 | | 空值 | 支持 `nullptr` | 不支持 | | 重定向 | 可修改指向 | 不可重新绑定 | | 内存管理 | 需手动处理 | 自动绑定，无直接管理职责 | | 适用场景 | 动态内存、可选参数、多级间接访问 | 函数参数、返回值优化、简化代码 |
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值