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

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执行指针类型与整数和其他指针类型之间的不安全转换。只有当我们知道自己在做什么并且了解别名问题时，才能使用此选项。

这能回答你的问题吗？

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

如果你了解一点内部情况，可能会有所帮助。。。

静态铸造

C++编译器已经知道如何在浮点到整型等缩放器类型之间进行转换。请对它们使用static_cast。当您要求编译器从类型A转换为B时，static_cast调用B的构造函数，将A作为参数传递。或者，A可以有一个转换运算符（即A:：运算符B（））。如果B没有这样的构造函数，或者A没有转换运算符，那么就会出现编译时错误。如果A和B位于继承层次结构（或void）中，则从A*到B*的强制转换总是成功的，否则会出现编译错误。Gotcha：若将基指针强制转换为派生指针，但若实际对象不是真正的派生类型，那个么就不会出现错误。你得到了错误的指针，很可能在运行时出现了segfault。A&到B&也是如此。Gotcha：从派生到基础或反之亦然，创建新副本！对于来自C#/Java的人来说，这可能是一个巨大的惊喜，因为结果基本上是从Derived创建的一个截断对象。

动态铸造

dynamiccast使用运行时类型信息来确定强制转换是否有效。例如，如果指针实际上不是派生类型，（Base*）到（Derived*）可能会失败。这意味着，dynamic_cast与static_cast相比非常昂贵！对于A*到B*，如果强制转换无效，则dynamic_cast将返回nullptr。对于A&toB&，如果强制转换无效，则dynamic_cast将抛出bad_cast异常。与其他强制转换不同，存在运行时开销。

常量_成本

虽然static_cast可以从非常量转换为常量，但它不能反过来。const_cast可以实现这两种方式。其中一个方便的例子是迭代一些容器，比如set＜T＞，它只将元素作为常量返回，以确保不更改其键。然而，若您的意图是修改对象的非键成员，那个么应该可以。您可以使用const_cast来删除常量。另一个例子是当您想要实现T&SomeClass:：foo（）以及常量T&SomeClass：：foo）const时。为了避免代码重复，可以将const_cast应用于从一个函数返回另一个函数的值。

重新解释（_C）

这基本上意味着在这个内存位置取这些字节，并将其视为给定的对象。例如，您可以将4字节的float加载到4字节的int，以查看float中的位的外观。显然，如果数据不适合该类型，您可能会得到segfault。此强制转换没有运行时开销。

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

除了到目前为止的其他答案之外，这里有一个不明显的例子，其中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);

（上面给出了大量的理论和概念解释）

下面是我使用static_cast、dynamic_cast、const_cast、reinterpret_cast时的一些实际示例。

（也可参考此来理解解释：http://www.cplusplus.com/doc/tutorial/typecasting/)

静态铸造：

OnEventData(void* pData)

{
  ......

  //  pData is a void* pData, 

  //  EventData is a structure e.g. 
  //  typedef struct _EventData {
  //  std::string id;
  //  std:: string remote_id;
  //  } EventData;

  // On Some Situation a void pointer *pData
  // has been static_casted as 
  // EventData* pointer 

  EventData *evtdata = static_cast<EventData*>(pData);
  .....
}

dynamic_cast：

void DebugLog::OnMessage(Message *msg)
{
    static DebugMsgData *debug;
    static XYZMsgData *xyz;

    if(debug = dynamic_cast<DebugMsgData*>(msg->pdata)){
        // debug message
    }
    else if(xyz = dynamic_cast<XYZMsgData*>(msg->pdata)){
        // xyz message
    }
    else/* if( ... )*/{
        // ...
    }
}

常量成本（_C）：

// *Passwd declared as a const

const unsigned char *Passwd


// on some situation it require to remove its constness

const_cast<unsigned char*>(Passwd)

重新解释（_C）：

typedef unsigned short uint16;

// Read Bytes returns that 2 bytes got read. 

bool ByteBuffer::ReadUInt16(uint16& val) {
  return ReadBytes(reinterpret_cast<char*>(&val), 2);
}