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

虽然其他答案很好地描述了C++转换之间的所有差异，但我想补充一点，为什么不应该使用C样式转换（Type）var和Type（var）。

对于C++初学者来说，C风格的强制转换看起来像是C++强制转换的超集操作（static_cast＜＞（）、dynamic_cast＜＜（）、const_cast＜>（）、reinterpret_cast＜＞（。事实上，C样式转换是超集，编写起来更短。

C风格转换的主要问题是它们隐藏了开发人员转换的真实意图。C样式强制转换几乎可以执行所有类型的强制转换，从static_cast＜>（）和dynamic_cast＜＞（）执行的通常安全的强制转换到const_cast＜（）等潜在的危险强制转换，其中可以删除const修饰符，以便可以修改const变量并重新解释cast＜＞（，甚至可以将整数值重新解释为指针。

这是样品。

int a=rand(); // Random number.

int* pa1=reinterpret_cast<int*>(a); // OK. Here developer clearly expressed he wanted to do this potentially dangerous operation.

int* pa2=static_cast<int*>(a); // Compiler error.
int* pa3=dynamic_cast<int*>(a); // Compiler error.

int* pa4=(int*) a; // OK. C-style cast can do such cast. The question is if it was intentional or developer just did some typo.

*pa4=5; // Program crashes.

C++转换被添加到语言中的主要原因是为了让开发人员明确自己的意图——为什么要进行转换。通过使用在C++中完全有效的C样式转换，您的代码可读性降低，更容易出错，尤其是对于其他没有创建代码的开发人员。因此，为了使代码更加可读和明确，您应该始终倾向于C++转换而不是C样式转换。

这是Bjarne Stroustrup（C++的作者）的书《C++编程语言》第四版第302页的一段简短引用。

这种C样式转换比命名的转换运算符更危险因为在大型程序中很难发现这种符号，而且程序员想要进行的转换也不明确。

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

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、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);
}

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）。