当两个链接的 static_cast 可以完成它的工作时，为什么我们在 C++ 中有 reinterpret_cast ?

Say I want to cast A* to char* and vice-versa, we have two choices (I mean, many of us think we've two choices, because both seems to work! Hence the confusion!):

struct A
{
    int age;
    char name[128];
};

A a;
char *buffer = static_cast<char*>(static_cast<void*>(&a)); //choice 1
char *buffer = reinterpret_cast<char*>(&a); //choice 2

两者都工作正常.

//convert back
A *pA = static_cast<A*>(static_cast<void*>(buffer)); //choice 1
A *pA = reinterpret_cast<A*>(buffer); //choice 2

即使这样也能正常工作！

Even this works fine!

那么当两个链式 static_cast 可以完成它的工作时，为什么我们在 C++ 中有 reinterpret_cast ?

So why do we have reinterpret_cast in C++ when two chained static_cast can do its job?

你们中的一些人可能认为这个主题是之前的主题的重复，例如在这篇文章的底部列出，但事实并非如此.这些主题只是理论上讨论，但他们都没有给出一个例子来说明为什么确实需要reintepret_cast，以及两个 static_cast 会肯定失败.我同意，一个 static_cast 会失败.但是两个呢?

Some of you might think this topic is a duplicate of the previous topics such as listed at the bottom of this post, but it's not. Those topics discuss only theoretically, but none of them gives even a single example demonstrating why reintepret_cast is really needed, and two static_cast would surely fail. I agree, one static_cast would fail. But how about two?

如果两个链式static_cast的语法看起来很麻烦，那么我们可以编写一个函数模板，让它对程序员更友好:

If the syntax of two chained static_cast looks cumbersome, then we can write a function template to make it more programmer-friendly:

template<class To, class From>
To any_cast(From v)
{
    return static_cast<To>(static_cast<void*>(v));
}

然后我们可以这样使用:

And then we can use this, as:

char *buffer = any_cast<char*>(&a); //choice 1
char *buffer = reinterpret_cast<char*>(&a); //choice 2

//convert back
A *pA = any_cast<A*>(buffer); //choice 1
A *pA = reinterpret_cast<A*>(buffer); //choice 2

此外，请参阅 any_cast 可能有用的这种情况:fstream 读写成员函数的正确转换.

Also, see this situation where any_cast can be useful: Proper casting for fstream read and write member functions.

所以我的问题基本上是，

So my question basically is,

• 为什么我们在 C++ 中有 reinterpret_cast?
• 请给我举一个例子，其中两个链式 static_cast 肯定无法完成相同的工作?

• Why do we have reinterpret_cast in C++?
• Please show me even a single example where two chained static_cast would surely fail to do the same job?

• 使用哪个演员表；static_cast 还是 reinterpret_cast?
• 演员从 Void* 到 TYPE*​​ : static_cast 或 reinterpret_cast

推荐答案

有些事情 reinterpret_cast 可以做到而 static_cast 的序列无法做到(全部来自 C++03 5.2.10):

There are things that reinterpret_cast can do that no sequence of static_casts can do (all from C++03 5.2.10):

• 指针可以显式转换为任何足够大的整数类型以容纳它.

• A pointer can be explicitly converted to any integral type large enough to hold it.

整数类型或枚举类型的值可以显式转换为指针.

A value of integral type or enumeration type can be explicitly converted to a pointer.

指向函数的指针可以显式转换为指向不同类型函数的指针.

A pointer to a function can be explicitly converted to a pointer to a function of a different type.