C++ 如何阅读这些表达：*&；指针VS&*指针_C++_C_Pointers

C++ 如何阅读这些表达：*&；指针VS&*指针

c++ c pointers

C++ 如何阅读这些表达：*&；指针VS&*指针,c++,c,pointers,C++,C,Pointers,如果我有： int j = 8; int *pointer = &j; 如果我这样做了： &*pointer == *&pointer 返回1（true）但我对第二种说法有疑问： *(&pointer) // Evaluates to the address of j &*指针返回指针指向的地址（首先计算* 然后&） *&指针返回指针地址，然后返回指针指向的内容。。。但这是变量，而不是地址。所以我怀疑 &*pointer取消对指针（下图中的1）的引用，为

如果我有：

int j = 8;
int *pointer = &j;

如果我这样做了：

&*pointer == *&pointer

（

true

）

但我对第二种说法有疑问：

*(&pointer) // Evaluates to the address of j

&*指针

返回指针指向的地址（首先计算* 然后&）

*&指针

返回指针地址，然后返回指针指向的内容。。。但这是变量，而不是地址。所以我怀疑

&*pointer

取消对指针（下图中的1）的引用，为您提供

int

对象（2），然后获取该对象的地址，该地址当然与指针（1）的值相同

*&pointer

获取指针（4.）的地址以获取指向该指针（3.）的指针，然后取消引用该地址以再次获取指针（4.）

您缺少的重要部分是

指针

是

int

的地址，因此

指针

是地址的地址。在C中，从右到左读取类型的成功率通常要高得多

 int *pointer = &j;

 (int *) = the pointer to an integer
 (&) = the address of

所以

由于指针的地址可以分配给指针（任何东西的地址都可以分配给指针），而指向任何东西的指针也是指针，因此您将获得工作类型方面的分配（但我认为这不是很实用）。

它们是相同的，因为没有其他意义

&*pointer

是指针指向的对象的地址，这是指针本身的值（存储在指针中的地址）

*&指针

是由

指针

的地址所指向的对象（被解除引用的

指针

变量的地址）-同样，这就是

指针

本身

*&指针

返回指针地址，然后返回指针指向的内容。。。但这是变量，而不是地址。所以我怀疑

让我们一步一步来：

```
指针
```
的类型为
```
int**
```
，指向
```
指针
```
变量
```
*&pointer
```
取消上述引用，实际上相当于
```
指针
```

只要

指针

是指向基本类型的原始指针，这些表达式就是等价的（这样

运算符&

和

运算符*

不会重载，否则等价性可能不成立）

事实上，这句话：

*(&pointer) // Evaluates to the address of j

首先计算

指针的地址，然后取消引用它。这再次给出了指针的值，它是j
的地址（因为这就是初始化指针的方式）。另一方面，这个表达式：
&(*pointer) // Evaluates to the address of j

首先解引用指针
（引用j
），然后获取其地址（从而计算为j
）
如您所见，这两个表达式的计算结果都是j
，因此它们是等效的。
&*指针是&（*指针）
，并返回指针指向的值的地址或指针
*&指针
是*（&指针）
并返回&指针
指向的值，或指针
指针
指向内存中的某个地址；它驻留在内存中的某个其他地址
&*pointer // (*pointer) - dereference `pointer`, now you have `j`
          // &(*pointer) - the address of `j`(that's the data that `pointer` has)

其中：
*&pointer //(&pointer) - the address of pointer(where pointer resides in memory)
          // *(&pointer) - deference that address and you get `pointer`


我总是发现指针更容易通过图片进行跟踪，因此本图可能有助于理解它们为何相同：
//In case of &*pointer, we start with the pointer, the dereference it giving us j
//Then taking the address of that brings us back to pointer:

                                           +--&(*pointer)-----------+
                                           |                        |
memory address            0x7FFF3210       |            0x7FFF0123  |
                        +------------+     |             +-----+    |
data present            | pointer =  | <---+        +->  | j=8 |----+
                        | 0x7FFF0123 | ->(*pointer)-+    +-----+
                        +------------+

//in the *&pointer case, we start with the pointer, take the address of it, then
//dereference that address bring it back to pointer


memory address           +------------>  0x7FFF3210 ----*(&pointer)--+  
                         |                                           |
                         |              +------------+               |   
data present             |              | pointer =  | <----------- -+   
                         +--&pointer ---| 0x7FFF0123 |         
                                        +------------+

//在&*指针的情况下，我们从指针开始，它的解引用给我们j
//然后把地址带回到指针：
+--&（*指针）-----------+
|                        |
内存地址0x7FFF3210 | 0x7FFF0123|
+------------+     |             +-----+    |
数据存在|指针=| | j=8|----+
|0x7FFF0123 |->（*指针）-++-----+
+------------+
//在*&指针的情况下，我们从指针开始，获取它的地址，然后
//取消对该地址的引用，使其返回指针
内存地址+------------->0x7FFF3210---*（&指针）--+
|                                           |
|              +------------+               |   
数据存在| |指针=|您怀疑它们是否正确，因为它们都具有从右到左的关联性。但是在*&pointer
-*
无法首先求值的情况下，它将转换为（&pointer）
，然后*
是要执行的第二个操作。但我猜编译器总是优化*&指针
和&*指针
到指针
。（这就是埃德温·巴克的答案所说的），您可以使用GCC-s
选项进行检查。@GrijeshChauhan:Hmm。。不一定安全（如果我们不是在谈论裸指针）。例如，如果pointer
是迭代器，*（&pointer）
将生成类型为iterator
的对象，其中&（*pointer）
将生成类型为iterator:：value\u类型的对象。如果未来的读者考虑将裸体指针的行为外推到看起来像裸体指针但实际上不是的东西，我想编译器总是优化*&pointer
和&*pointer
到指针
。请阅读我对OP问题的评论。如果我错了，请告诉我。@GrijeshChauhan刚刚检查了C标准，*
没有在&*指针中计算。但是，在C++中，这可能会稍微复杂一些。
*&pointer //(&pointer) - the address of pointer(where pointer resides in memory)
          // *(&pointer) - deference that address and you get `pointer`

//In case of &*pointer, we start with the pointer, the dereference it giving us j
//Then taking the address of that brings us back to pointer:

                                           +--&(*pointer)-----------+
                                           |                        |
memory address            0x7FFF3210       |            0x7FFF0123  |
                        +------------+     |             +-----+    |
data present            | pointer =  | <---+        +->  | j=8 |----+
                        | 0x7FFF0123 | ->(*pointer)-+    +-----+
                        +------------+

//in the *&pointer case, we start with the pointer, take the address of it, then
//dereference that address bring it back to pointer


memory address           +------------>  0x7FFF3210 ----*(&pointer)--+  
                         |                                           |
                         |              +------------+               |   
data present             |              | pointer =  | <----------- -+   
                         +--&pointer ---| 0x7FFF0123 |         
                                        +------------+