为了理解，让我们考虑下面的代码片段：

struct Foo{};
struct Bar{};

int main(int argc, char** argv)
{
    Foo* f = new Foo;

    Bar* b1 = f;                              // (1)
    Bar* b2 = static_cast<Bar*>(f);           // (2)
    Bar* b3 = dynamic_cast<Bar*>(f);          // (3)
    Bar* b4 = reinterpret_cast<Bar*>(f);      // (4)
    Bar* b5 = const_cast<Bar*>(f);            // (5)

    return 0;
}

只有第（4）行编译没有错误。只能使用reinterpret_cast将指向对象的指针转换为指向任何无关对象类型的指针。

需要注意的一点是：dynamic_cast在运行时会失败，但在大多数编译器上，它也会编译失败，因为被转换的指针的结构中没有虚拟函数，这意味着dynamic_cast只能与多态类指针一起工作。

何时使用C++转换：

使用static_cast等效于进行值转换的C样式转换，或者当我们需要将指针从类显式上转换到其超类时。使用const_cast删除const限定符。使用reinterpret_cast执行指针类型与整数和其他指针类型之间的不安全转换。只有当我们知道自己在做什么并且了解别名问题时，才能使用此选项。

除了到目前为止的其他答案之外，这里有一个不明显的例子，其中static_cast不够，因此需要重新解释cast。假设有一个函数在输出参数中返回指向不同类（不共享公共基类）对象的指针。此类函数的一个真实示例是CoCreateInstance（）（请参阅最后一个参数，实际上是void**）。假设您从这个函数中请求特定的对象类，这样您就可以提前知道指针的类型（这通常是针对COM对象的）。在这种情况下，不能使用static_cast将指向指针的指针转换为void**：您需要重新解释cast＜void**＞（&yourPointer）。

在代码中：

#include <windows.h>
#include <netfw.h>
.....
INetFwPolicy2* pNetFwPolicy2 = nullptr;
HRESULT hr = CoCreateInstance(__uuidof(NetFwPolicy2), nullptr,
    CLSCTX_INPROC_SERVER, __uuidof(INetFwPolicy2),
    //static_cast<void**>(&pNetFwPolicy2) would give a compile error
    reinterpret_cast<void**>(&pNetFwPolicy2) );

但是，static_cast适用于简单指针（而不是指向指针的指针），因此可以通过以下方式重写上述代码以避免重新解释cast（代价是额外的变量）：

#include <windows.h>
#include <netfw.h>
.....
INetFwPolicy2* pNetFwPolicy2 = nullptr;
void* tmp = nullptr;
HRESULT hr = CoCreateInstance(__uuidof(NetFwPolicy2), nullptr,
    CLSCTX_INPROC_SERVER, __uuidof(INetFwPolicy2),
    &tmp );
pNetFwPolicy2 = static_cast<INetFwPolicy2*>(tmp);

这能回答你的问题吗？

我从来没有使用过reinterpret_cast，我想知道遇到一个需要它的案例是否不是糟糕设计的味道。在代码库中，我使用了很多dynamic_cast。与static_cast的区别在于dynamic_cast执行运行时检查，这可能（更安全），也可能（开销更大）是您想要的（请参见msdn）。

使用dynamic_cast转换继承层次结构中的指针/引用。对普通类型转换使用static_cast。使用reinterpret_cast对位模式进行低级重新解释。使用时要格外小心。使用const_cast丢弃const/vatile。避免这种情况，除非您使用的是常量错误的API。

reinterpret_cast的好特性（其他答案中没有提到）是它允许我们为函数类型创建一种void*指针。通常，对于对象类型，使用static_cast检索存储在void*中的指针的原始类型：

  int i = 13;
  void *p = &i;
  auto *pi = static_cast<int*>(p);

对于函数，我们必须使用reinterpret_cast两次：

#include<iostream>

using any_fcn_ptr_t = void(*)();


void print(int i)
{
   std::cout << i <<std::endl;
}

int main()
{     
  //Create type-erased pointer to function:
  auto any_ptr = reinterpret_cast<any_fcn_ptr_t>(&print);
  
  //Retrieve the original pointer:
  auto ptr = reinterpret_cast< void(*)(int) >(any_ptr);
  
  ptr(7);
}

使用reinterpret_cast，我们甚至可以为指向成员函数的指针获得类似类型的void*指针。

与普通的void*和static_cast一样，C++保证ptr指向print函数（只要我们将正确的类型传递给reinterpret_cast）。

staticcast是您应该尝试使用的第一个强制转换。它执行类型之间的隐式转换（例如int到float，或指向void*的指针），还可以调用显式转换函数（或隐式转换函数）。在许多情况下，显式声明static_cast是不必要的，但需要注意的是，t（something）语法相当于（t）something，应该避免（稍后将详细介绍）。然而，T（something，something_else）是安全的，并保证调用构造函数。

staticcast还可以通过继承层次结构进行转换。当向上转换（向基类）时，这是不必要的，但当向下转换时，只要不通过虚拟继承进行转换，就可以使用它。但是，它不进行检查，并且将层次结构静态转换为实际上不是对象类型的类型是未定义的行为。

const_cast可用于移除或添加常量到变量；没有其他C++转换能够移除它（甚至没有重新解释cast）。需要注意的是，只有当原始变量为常量时，修改以前的常量值才是未定义的；如果使用它来删除对未使用const声明的对象的引用的const，那么它是安全的。例如，当基于常量重载成员函数时，这很有用。它还可以用于向对象添加常量，例如调用成员函数重载。

constcast在volatile上也有类似的作用，尽管这不太常见。

dynamiccast专门用于处理多态性。您可以将指向任何多态类型的指针或引用强制转换为任何其他类类型（多态类型至少有一个声明或继承的虚拟函数）。你可以使用它不仅仅是向下投掷——你可以向侧面投掷，甚至向上投掷另一个链条。dynamic_cast将查找所需的对象，并在可能的情况下将其返回。如果不能，它将在指针的情况下返回nullptr，或者在引用的情况下抛出std:：bad_cast。

不过dynamiccast有一些限制。如果继承层次结构中有多个相同类型的对象（所谓的“可怕的钻石”），并且您没有使用虚拟继承，那么它就不起作用。它也只能通过公共继承——它总是无法通过受保护或私人继承。然而，这很少是一个问题，因为这种形式的继承是罕见的。

reinterprecast是最危险的演员，应该非常谨慎地使用。它将一种类型直接转换为另一种类型，例如将值从一个指针转换为另另一个指针，或将指针存储在int中，或其他各种讨厌的事情。在很大程度上，使用reinterpret_cast可以得到的唯一保证是，通常情况下，如果将结果强制转换回原始类型，将得到完全相同的值（但如果中间类型小于原始类型，则不会）。还有许多转换是reinterpret_cast无法完成的。它主要用于特别奇怪的转换和位操作，例如将原始数据流转换为实际数据，或将数据存储在指向对齐数据的指针的低位。

C样式转换和函数样式转换分别是使用（类型）对象或类型（对象）的转换，在功能上是等效的。它们被定义为以下成功的第一个：

常量_成本static_cast（尽管忽略访问限制）static_cast（见上文），然后是const_cast重新解释（_C）重新解释成本，然后常量成本

因此，在某些情况下，它可以用作其他强制转换的替代品，但可能会非常危险，因为它可以转换为重新解释强制转换，当需要显式强制转换时，应首选后者，除非您确定static_cast将成功或重新解释强制。即使如此，也要考虑更长、更明确的选项。

C样式转换在执行static_cast时也会忽略访问控制，这意味着它们能够执行其他转换无法执行的操作。不过，这基本上是一个拙劣的说法，在我看来，这只是避免C型造型的另一个原因。