const_cast

根據http://www.cplusplus.com的說法，const_cast用於物件指標或引用的const的新增和刪除操作

例子如下：

// const_cast
#include <iostream>
using namespace std;

void print (char * str)
{
  cout << str << '\n';
}

int main () {
  const char * c = "sample text";
  print ( const_cast<char *> (c) );
  return
 
 0;
}

輸出為

sample text

函式指標和成員函式指標不可用於const_cast

const_cast可以使實際指代const物件的到非const型別的引用或指標，但是通過非const訪問路徑修改const物件則是未定義行為。

更詳細的例子

#include <iostream>

struct type {
    type() :i(3) {}
    void m1(int v) const {
        // this->i = v;                 // 編譯錯誤：這是指向 const 的指標
        const_cast
 
<type*>(this)->i = v; // 只要物件不是 const 就 OK
    }
    int i;
};

int main() 
{
    int i = 3;                    // i 不宣告為 const
    const int& cref_i = i; 
    const_cast<int&>(cref_i) = 4; // OK ：修改 i
    std::cout << "i = " << i << '\n';

    type t; // note, if this is const type t;, then t.m1(4); is UB
 

    t.m1(4);
    std::cout << "type::i = " << t.i << '\n';

    const int j = 3; // j 宣告為 const
    int* pj = const_cast<int*>(&j);
    // *pj = 4;         // 未定義行為！

    void (type::*mfp)(int) const = &type::m1; // 指向成員函式指標
//  const_cast<void(type::*)(int)>(mfp); // 編譯錯誤： const_cast 對函式指標不起作用
}

輸出

i = 4
type::i = 4

reinterpret_cast

reinterpret_cast可以在任意型別指標進行轉換，哪怕是不相關的型別。

還可用於指標或引用與整型的相互轉化，不單是int，還包括short、long等整數型別。

原因在於reinterpret_cast是“simple binary copy”，cplusplus的原話是“The operation result is a simple binary copy of the value from one pointer to the other. All pointer conversions are allowed: neither the content pointed nor the pointer type itself is checked.”

經過測試，整型與char *之間的轉化也可以正常進行

cppreference的例子

#include <cstdint>
#include <cassert>
#include <iostream>
int f() { return 42; }
int main()
{
    int i = 7;

    // 指標到整數並轉回
    uintptr_t v1 = reinterpret_cast<uintptr_t>(&i); // static_cast 為錯誤
    std::cout << "The value of &i is 0x" << std::hex << v1 << '\n';
    int* p1 = reinterpret_cast<int*>(v1);
    assert(p1 == &i);

    // 到另一函式指標並轉回
    void(*fp1)() = reinterpret_cast<void(*)()>(f);
    // fp1(); 未定義行為
    int(*fp2)() = reinterpret_cast<int(*)()>(fp1);
    std::cout << std::dec << fp2() << '\n'; // 安全

    // 通過指標的類型別名使用
    char* p2 = reinterpret_cast<char*>(&i);
    if(p2[0] == '\x7')
        std::cout << "This system is little-endian\n";
    else
        std::cout << "This system is big-endian\n";

    // 通過引用的類型別名使用
    reinterpret_cast<unsigned int&>(i) = 42;
    std::cout << i << '\n';

    const int &const_iref = i;
    // int &iref = reinterpret_cast<int&>(const_iref); // 編譯錯誤——不能去除 const
    // 必須用 const_cast 代替： int &iref = const_cast<int&>(const_iref);
}

輸出

The value of &i is 0x7fff352c3580
42
This system is little-endian
42

static_cast

static_cast可以在有聯絡的型別之間進行指標轉換（between pointers to related classes），不但包括派生類轉換基類，也包括基類轉換派生類。

static_cast還可以完成以下兩種

Convert from void* to any pointer type.可以有void *到任何型別

Convert integers, floating-point values and enum types to enum types.由整數、浮點、列舉值到列舉值

此外

Explicitly call a single-argument constructor or a conversion operator. 呼叫單一引數的建構函式或轉換的過載符號

Convert to rvalue references. （由左值）轉化成右值的引用

Convert enum class values into integers or floating-point values. 列舉類轉化為整數、浮點數

Convert any type to void, evaluating and discarding the value. 任意型別到void，求值後捨棄該值

示例

#include <vector>
#include <iostream>

struct B {
    int m = 0;
    void hello() const {
        std::cout << "Hello world, this is B!\n";
    }
};
struct D : B {
    void hello() const {
        std::cout << "Hello world, this is D!\n";
    }
};

enum class E { ONE = 1, TWO, THREE };
enum EU { ONE = 1, TWO, THREE };

int main()
{
    // 1: 初始化轉換
    int n = static_cast<int>(3.14); 
    std::cout << "n = " << n << '\n';
    std::vector<int> v = static_cast<std::vector<int>>(10);
    std::cout << "v.size() = " << v.size() << '\n';

    // 2: 靜態向下轉型
    D d;
    B& br = d; // 通過隱式轉換向上轉型
    br.hello();
    D& another_d = static_cast<D&>(br); // 向下轉型
    another_d.hello();

    // 3: 左值到亡值
    std::vector<int> v2 = static_cast<std::vector<int>&&>(v);
    std::cout << "after move, v.size() = " << v.size() << '\n';

    // 4: 棄值表示式
    static_cast<void>(v2.size());

    // 5. 隱式轉換的逆
    void* nv = &n;
    int* ni = static_cast<int*>(nv);
    std::cout << "*ni = " << *ni << '\n';

    // 6. 陣列到指標後隨向上轉型
    D a[10];
    B* dp = static_cast<B*>(a);

    // 7. 有作用域列舉到 int 或 float
    E e = E::ONE;
    int one = static_cast<int>(e);
    std::cout << one << '\n';

    // 8. int 到列舉，列舉到另一列舉
    E e2 = static_cast<E>(one);
    EU eu = static_cast<EU>(e2);

    // 9. 指向成員指標向上轉型
    int D::*pm = &D::m;
    std::cout << br.*static_cast<int B::*>(pm) << '\n';

    // 10. void* 到任何型別
    void* voidp = &e;
    std::vector<int>* p = static_cast<std::vector<int>*>(voidp);
}

輸出

n = 3
v.size() = 10
Hello world, this is B!
Hello world, this is D!
after move, v.size() = 0
*ni = 3
1
0

dynamic_cast

dynamic_cast只能用於類或者void *的指標、引用轉換，同時必須為多型以使用執行時檢查的

例子

#include <iostream>

struct V {
    virtual void f() {};  // 必須為多型以使用執行時檢查的 dynamic_cast
};
struct A : virtual V {};
struct B : virtual V {
  B(V* v, A* a) {
    // 構造中轉型（見後述 D 的建構函式中的呼叫）
    dynamic_cast<B*>(v); // 良好定義： v 有型別 V* ， B 的 V 基類，產生 B*
    dynamic_cast<B*>(a); // 未定義行為： a 有型別 A* ， A 非 B 的基類
  }
};
struct D : A, B {
    D() : B((A*)this, this) { }
};

struct Base {
    virtual ~Base() {}
};

struct Derived: Base {
    virtual void name() {}
};

int main()
{
    D d; // 最終匯出類
    A& a = d; // 向上轉型，可以用 dynamic_cast ，但不必須
    D& new_d = dynamic_cast<D&>(a); // 向下轉型
    B& new_b = dynamic_cast<B&>(a); // 側向轉型


    Base* b1 = new Base;
    if(Derived* d = dynamic_cast<Derived*>(b1))
    {
        std::cout << "downcast from b1 to d successful\n";
        d->name(); // 呼叫安全
    }

    Base* b2 = new Derived;
    if(Derived* d = dynamic_cast<Derived*>(b2))
    {
        std::cout << "downcast from b2 to d successful\n";
        d->name(); // 呼叫安全
    }

    delete b1;
    delete b2;
}

輸出

downcast from b2 to d successful

dynamic_cast與static_cast在類轉換上的不同在於，dynamic_cast會確保轉化成功，在轉化不成功時會設定為NULL，如上例中

Derived* d = dynamic_cast<Derived*>(b1)