(new-type) expression
new-type (expression)

char c = 10;      // 1 個字節(jié)
int *p = (int *)&c;  // 4 個字節(jié)（32bit platform）

*p = 5;        // 內(nèi)存踩臟
int *q = static_cast<int *>(&c); // 使用static_cast可在編譯階段將該錯誤檢查出來。

#include <iostream>

class A
{
public:
 A(){}
 ~A(){}
 
private:
 int i, j;
};

class C
{
public:
 C(){}
 ~C(){}

 void printC()
 {
  std::cout <<"call printC() in class C" <<std::endl;
 }
private:
 char c1, c2;
};

int main()
{ 
 A *ptrA = new A;
 //C *ptrC = static_cast<C *>(ptrA);
 // 編譯無法通過，提示：
 // In function ‘int main()':
 // error: invalid static_cast from type ‘A*' to type ‘C*'
 
 C *ptrC = (C *)(ptrA);
 ptrC->printC();
 // 編譯正常通過。
 // 盡管這個時候能夠正常調(diào)用printC，但實際上這種做法的結(jié)果是“undefined”
 // 嘗試過，如果添加一些數(shù)據(jù)成員的運算，這個時候?qū)沟眠\算結(jié)果無法預(yù)測
 // 所以，在運行時候該邏輯相關(guān)的行為是不清晰的。
 
 return 0;
} 

#include <iostream>

class A
{
public:
 A():i(1), j(1){}
 ~A(){}
 
 void printA()
 {
  std::cout <<"call printA() in class A" <<std::endl;
 }
 
 void printSum()
 {
  std::cout <<"sum = " <<i+j <<std::endl;
 }
 
private:
 int i, j;
};

class B : public A
{
public:
 B():a(2), b(2) {}
 ~B(){}

 void printB()
 {
  std::cout <<"call printB() in class B" <<std::endl;
 }
 
 void printSum()
 {
  std::cout <<"sum = " <<a+b <<std::endl;
 }
 
 void Add()
 {
  a++;
  b++;
 }
 
private:
 double a, b;
};

int main()
{   
 B *ptrB = new B;
 ptrB->printSum();
 //打印結(jié)果：sum = 4
 A *ptrA = static_cast<B *>(ptrB);  
 ptrA->printA();
 ptrA->printSum();
 //打印結(jié)果：sum = 2
 //在進行upcast的時候，指針指向的對象的行為與指針的類型相關(guān)。
 
 
 ptrA = new A;
 ptrA->printSum();
 //打印結(jié)果：sum = 2 
 ptrB = static_cast<B *>(ptrA);
 ptrB->printB();
 ptrB->printSum(); 
 //打印結(jié)果：sum = 0
 //在進行downcast的時候，其行為是“undefined”。
 
 //B b;
 //B &rB = b;
 //rB.printSum();
 //打印結(jié)果：sum = 4
 //A &rA = static_cast<A &>(rB);  
 //rA.printA();
 //rA.printSum();
 //打印結(jié)果：sum = 2
 //在進行upcast的時候，引用指向的對象的行為與引用的類型相關(guān)。
 
 //A a;
 //A &rA = a;
 //rA.printSum();
 //打印結(jié)果：sum = 4
 //B &rB = static_cast<B &>(rA);  
 //rB.printB();
 //rB.printSum();
 //打印結(jié)果：sum = 5.18629e-317 
 //在進行downcast的時候，其行為是“undefined”。
 
 return 0;
}

#include <iostream>
#include <exception>

class A
{
public:
 virtual void print() 
 {
  std::cout <<"Welcome to WorldA!" <<std::endl;
 }
};

class B : public A
{
public:
 B():a(0), b(0) {}
 ~B(){}
 virtual void print() 
 {
  std::cout <<"Welcome to WorldB!" <<std::endl;
 }
private:
 double a, b;
};

int main()
{
 B *ptrB = new B;
 A *ptrA = dynamic_cast<A *>(ptrB);
 ptrA->print();
 //在虛繼承當(dāng)中，針對指針執(zhí)行upcast時dynamic_cast轉(zhuǎn)換的效果與static_cast一樣
 //對是否存在virtual沒有要求，會實際調(diào)用所指向?qū)ο蟮某蓡T。
  
 //A *ptrA = new A;
 //B *ptrB = dynamic_cast<B *>(ptrA);
 //ptrB->print();
 //Segmentation fault，針對指針執(zhí)行downcast時轉(zhuǎn)換不成功，返回NULL。
 
 //A a;
 //A &ra = a;
 //B &b = dynamic_cast<B &>(ra);
 //b.print();  
 //拋出St8bad_cast異常，針對引用執(zhí)行downcast時轉(zhuǎn)換不成功，拋出異常。
 
 //ptrA = new A;
 //ptrB = static_cast<B *>(ptrA);
 //ptrB->print();
 //使用static_cast進行downcast的時候，與dynamic_cast返回NULL不同，
 //這里會調(diào)用ptrB實際指向的對象的虛函數(shù)。
  
 //ptrA = new A;
 //ptrB = dynamic_cast<B *>(ptrA);
 //ptrB->print();
 //在進行downcast時，如果沒有virtual成員，那么在編譯時會提示： 
 // In function ‘int main()':
 // cannot dynamic_cast ‘ptrA' (of type ‘class A*') to type ‘class B*' (source type is not polymorphic)
 
 return 0;
}

#include <iostream>

class A
{
public:
 A(){}
 ~A(){}
 void print() 
 {
  std::cout <<"Hello World!" <<std::endl;
 }
};

class B
{
public:
 B():a(0), b(0) {}
 ~B(){}

 void call()
 {
  std::cout <<"Happy for your call!" <<std::endl;
 }

private:
 double a, b;
};

int main()
{
 //A *ptrA = new A;
 //B *ptrB = reinterpret_cast<B *>(ptrA);
 //ptrB->call();
 //正常編譯
 //A *ptrA = new A;
 //B *ptrB = (B *)(ptrA);
 //ptrB->call();
 //正常編譯
 //A *ptrA = new A; 
 //B *ptrB = static_cast<B *>(ptrA);
 //ptrB->call();
 //編譯不通過，提示：
 //In function ‘int main()':
 //error: invalid static_cast from type ‘A*' to type ‘B*'
 
 //char c;
 //char *pC = &c;
 //int *pInt = static_cast<int *>(pC);
 //編譯提示錯誤：error: invalid static_cast from type ‘char*' to type ‘int*'
 //int *pInt = reinterpret_cast<int *>(pC);
 //正常編譯。
 //int *pInt = (int *)(pC);
 //正常編譯。
 
 return 0;
}

     ----------------
     /  dynamic_cast \ -->同一繼承體系（virtual）的類指針或引用[更安全的downcast]
    ~~~~~~~~~~~~~~~~~~~~  
    /   static_cast  \ -->基礎(chǔ)類型[更安全]，同一繼承體系的類指針或引用
   ~~~~~~~~~~~~~~~~~~~~~~~~
   /  reinterpret_cast  \ -->與C-Like的作用一致，沒有任何靜態(tài)或者動態(tài)的checking機制
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  /     C-Like      \ -->基礎(chǔ)類型，同一繼承體系的類指針或引用,不同繼承體系類的指針或引用
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

const int myConst = 15;
int *nonConst = const_cast<int *>(&myConst);

void print(int *p)
{
  std::cout << *p;
}

print(&myConst); // 編譯錯誤：error: invalid conversion from ‘const int*' to ‘int*'
print(nonConst); // 正常

const int myConst = 15;
int *nonConst = const_cast<int *>(&myConst);

*nonConst = 10;
// 如果該變量存放在read-only內(nèi)存區(qū)當(dāng)中，在運行時可能會出現(xiàn)錯誤。