在C++中有四種類型轉換

1.static_cast：這個是最常用的型別轉換，凡是C++隱式執行的型別轉換都可以用static_cast顯式完成。在隱式轉換時有時編譯器會有警告資訊，但是顯示轉換(使用static_cast)就不會有。static_cast還會進行一些基礎的型別檢查，能在編譯期發現錯誤。

float f=0;
int a=(int)f; //強行轉換，可能會有警告
int a=static_cast<int>f; //使用static_cast消除警告

2.const_cast：從名字可以看出和const有關，這個轉換的作用是去除或新增const特性，它可以將一個const變數轉換為非const變數，或將一個非const變數轉換為const變數。
3.dynamic_cast

implicit_cast和down_cast

　　在muduo有另外兩個轉換implicit_cast和down_cast(看註釋應該是google的程式碼)。什麼時候用，為什麼用基本上都在註釋裡面了，可以重點看下。

// Use implicit_cast as a safe version of static_cast or const_cast
 

// for upcasting in the type hierarchy (i.e. casting a pointer to Foo
// to a pointer to SuperclassOfFoo or casting a pointer to Foo to
// a const pointer to Foo).
// When you use implicit_cast, the compiler checks that the cast is safe.
// Such explicit implicit_casts are necessary in surprisingly many
// situations where C++ demands an exact type match instead of an
 

// argument type convertable to a target type.
//
// The From type can be inferred, so the preferred syntax for using
// implicit_cast is the same as for static_cast etc.:
//
//   implicit_cast<ToType>(expr)
//
// implicit_cast would have been part of the C++ standard library,
// but the proposal was submitted too late.  It will probably make
// its way into the language in the future.
template<typename To, typename From>
inline To implicit_cast(From const &f)
{
  return f;
}
// When you upcast (that is, cast a pointer from type Foo to type
// SuperclassOfFoo), it's fine to use implicit_cast<>, since upcasts
// always succeed.  When you downcast (that is, cast a pointer from
// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
// how do you know the pointer is really of type SubclassOfFoo?  It
// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
// when you downcast, you should use this macro.  In debug mode, we
// use dynamic_cast<> to double-check the downcast is legal (we die
// if it's not).  In normal mode, we do the efficient static_cast<>
// instead.  Thus, it's important to test in debug mode to make sure
// the cast is legal!
//    This is the only place in the code we should use dynamic_cast<>.
// In particular, you SHOULDN'T be using dynamic_cast<> in order to
// do RTTI (eg code like this:
//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
// You should design the code some other way not to need this.

template<typename To, typename From>     // use like this: down_cast<T*>(foo);
inline To down_cast(From* f)                     // so we only accept pointers
{
  // Ensures that To is a sub-type of From *.  This test is here only
  // for compile-time type checking, and has no overhead in an
  // optimized build at run-time, as it will be optimized away
  // completely.
  if (false)
  {
    implicit_cast<From*, To>(0);
  }

#if !defined(NDEBUG) && !defined(GOOGLE_PROTOBUF_NO_RTTI)
  assert(f == NULL || dynamic_cast<To>(f) != NULL);  // RTTI: debug mode only!
#endif
  return static_cast<To>(f);
}

　　在up_cast時應該使用implicit_cast替換static_cast,因為後者比前者要安全，以一個例子說明,在菱形繼承中，最底層的物件可以轉換為中層物件

#include<boost/implicit_cast.hpp>
#include<iostream>

class Top{};
class MiddleA:public Top{};
class MiddleB:public Top{};
class Bottom:public MiddleA,public MiddleB{};

void Function(MiddleA& A)
{
    std::cout<<"MiddleA Function"<<std::endl;
}
void Function(MiddleB& B)
{
    std::cout<<"MiddleB Function"<<std::endl;
}
int main()
{
    Bottom bottom;
    Function(bottom);
    return 0;
}

　　這時如果編譯，就會出現錯誤，因為在呼叫函式Function時，bottom既可以預設轉換為MiddleA，也可以預設轉換為MiddleB，如果不明確指出就會出現歧義。這時可以改為：
Function(static_cast<MiddleA&>(bottom));或Function(static_cast<MiddleB&>(bottom));
程式可以運行了。但是如果不小心這樣使用了：

Top top;
Function(static_cast<MiddleB&>top);

　　這樣編譯可以通過，但是在執行時可能崩潰，因為top不是“一種”MiddleB，但是static_cast不能發現這個問題，這時如果用implicit_cast就不會有這個問題了，在編譯時就會給出錯誤資訊。static_cast不進行真正的型別檢查(在down_cast和up_cast的時候)。implicit_cast只能用在up_cast，當需要down_cast(這種形式)時候我們就應該使用上面的down_cast(上面的程式碼)。
down_cast在debug模式下內部使用了dynamic_cast進行驗證，在release下使用static_cast替換dynamic_cast。

為什麼使用down_cast而不直接使用dynamic_cast?

1.因為但凡程式設計正確，dynamic_cast就可以用static_cast來替換，而後者比前者更有效率。
2.dynamic_cast可能失敗(在執行時crash)，執行時RTTI不是好的設計，不應該在執行時RTTI或者需要RTTI時一般都有更好的選擇。
知乎上有個討論 為什麼說不要使用 dynamic_cast，需要執行時確定型別資訊，說明設計有缺陷？ - 知乎

總結

　　在程式設計中，主要是我們自己程式碼編寫者要明確的知道當前是down_cast還是up_cast,up_cast那就使用implicit_cast,down_cast就用down_cast。