C++ ref和指针之间的不同行为

这只是我遇到的一个怪事，我不太明白发生了什么

int main()
{
    int i{ 5 };

    void* v = &i;

    int* t = reinterpret_cast<int*>(v);
    int u = reinterpret_cast<int&>(v);

    int i2 = *t;

}

intmain（）
{
int i{5}；
void*v=&i；
int*t=重新解释铸件（v）；
int u=重新解释铸件（v）；
int i2=*t；
}

t是正确的5，u是垃圾

---

发生了什么事？

v

存储

i

的地址，正如您所说，它是垃圾。（它不是真正的垃圾，但是值本身是没有意义的，除非它是

i

在这个特定的程序运行中的地址）

u

存储与

v

相同的值（按位），但重新解释为整数，因此它是“垃圾”

---

t

不是您所声称的5。或者，如果是这样，这是一个极不可能的巧合

t

是

i

的地址，而

i

是5，所以

*t

（也就是说，

t

被解除引用）是5。

v

存储

i

的地址，正如您所说的，它是垃圾。（它不是真正的垃圾，但是值本身是没有意义的，除非它是

i

在这个特定的程序运行中的地址）

u

存储与

v

相同的值（按位），但重新解释为整数，因此它是“垃圾”

---

t

不是您所声称的5。或者，如果是这样，这是一个极不可能的巧合

t

是

i

的地址，而

i

是5，所以

*t

（也就是说，

t

被解除引用）是5。

v

存储

i

的地址，正如您所说的，它是垃圾。（它不是真正的垃圾，但是值本身是没有意义的，除非它是

i

在这个特定的程序运行中的地址）

u

存储与

v

相同的值（按位），但重新解释为整数，因此它是“垃圾”

---

t

不是您所声称的5。或者，如果是这样，这是一个极不可能的巧合

t

是

i

的地址，而

i

是5，所以

*t

（也就是说，

t

被解除引用）是5。

v

存储

i

的地址，正如您所说的，它是垃圾。（它不是真正的垃圾，但是值本身是没有意义的，除非它是

i

在这个特定的程序运行中的地址）

u

存储与

v

相同的值（按位），但重新解释为整数，因此它是“垃圾”

t

不是您所声称的5。或者，如果是这样，这是一个极不可能的巧合

t

是

i

的地址，

i

是5，因此

*t

（即

t

被解除引用）是5

对我来说：

39fdb8 39fdb8

不是垃圾，而是

v

的值

对我来说：

39fdb8 39fdb8

不是垃圾，而是

v

的值

对我来说：

39fdb8 39fdb8

不是垃圾，而是

v

的值

对我来说：

39fdb8 39fdb8

---

不是垃圾，而是

v

u的值是int，v是指针*v是int，但我们应该 以下代码可以输出5

#include <iostream>
using namespace std;
int main()
{
    int i{ 5 };

    void* v = &i;

    int* t = reinterpret_cast<int*>(v);
    int u = reinterpret_cast<int&>(*(int*)v);

    int i2 = *t;

    std::cout << *t << std::endl;
    std::cout << u << std::endl;
    return 0;
}

#包括
使用名称空间std；
int main（）
{
int i{5}；
void*v=&i；
int*t=重新解释铸件（v）；
int u=重新解释铸件（*（int*）v；
int i2=*t；
u是int，v是指针*v是int，但我们应该
以下代码可以输出5

#include <iostream>
using namespace std;
int main()
{
    int i{ 5 };

    void* v = &i;

    int* t = reinterpret_cast<int*>(v);
    int u = reinterpret_cast<int&>(*(int*)v);

    int i2 = *t;

    std::cout << *t << std::endl;
    std::cout << u << std::endl;
    return 0;
}

#包括
使用名称空间std；
int main（）
{
int i{5}；
void*v=&i；
int*t=重新解释铸件（v）；
int u=重新解释铸件（*（int*）v；
int i2=*t；
u是int，v是指针*v是int，但我们应该
以下代码可以输出5

#include <iostream>
using namespace std;
int main()
{
    int i{ 5 };

    void* v = &i;

    int* t = reinterpret_cast<int*>(v);
    int u = reinterpret_cast<int&>(*(int*)v);

    int i2 = *t;

    std::cout << *t << std::endl;
    std::cout << u << std::endl;
    return 0;
}

#包括
使用名称空间std；
int main（）
{
int i{5}；
void*v=&i；
int*t=重新解释铸件（v）；
int u=重新解释铸件（*（int*）v；
int i2=*t；
u是int，v是指针*v是int，但我们应该
以下代码可以输出5

#include <iostream>
using namespace std;
int main()
{
    int i{ 5 };

    void* v = &i;

    int* t = reinterpret_cast<int*>(v);
    int u = reinterpret_cast<int&>(*(int*)v);

    int i2 = *t;

    std::cout << *t << std::endl;
    std::cout << u << std::endl;
    return 0;
}

#包括
使用名称空间std；
int main（）
{
int i{5}；
void*v=&i；
int*t=重新解释铸件（v）；
int u=重新解释铸件（*（int*）v；
int i2=*t；
STD:：CUT不需要混合C++和C风格的铸件。在这种情况下，它是足够简单的：<代码> int u=重新解释Type（*V）
@vershov恐怕没有这么简单，
void
是不完整的type@Praetorianreinterpret_cast是一个编译器指令，它指示编译器将表达式的位序列视为具有类型。@vershov迷人，但如何解除对
void*
的引用？@Praetorian
void*v
是“代码”> * V < /代码>是指针指向的位置的一系列序列。一旦我们将比特序列传递给<代码> RealTytRease我们不需要任何其他东西来构建新的类型，只是这个位的序列。不需要混合C++和C的流派风格。u=重新解释铸件（*v）
@vershov恐怕没有这么简单，
void
是不完整的type@Praetorianreinterpret_cast是一个编译器指令，它指示编译器将表达式的位序列视为具有类型。@vershov迷人，但如何解除对
void*
的引用？@Praetorian
void*v
是“代码”> * V < /代码>是指针指向的位置的一系列序列。一旦我们将比特序列传递给<代码> RealTytRease我们不需要任何其他东西来构建新的类型，只是这个位的序列。不需要混合C++和C的流派风格。u=重新解释演员表（*v）；
@vershov恐怕没有这么简单，
void
是不完整的type@Praetorianreinterpret_cast是一个编译器指令，它指示编译器将表达式的位序列视为具有类型。@vershov，但如何取消对
void的引用