static_cast和dynamic_cast是C++的類型轉換操作符。編譯器隱式執(zhí)行的任何類型轉換都可以由static_cast顯式完成，即父類和子類之間也可以利用static_cast進行轉換。而dynamic_cast只能用于類之間的轉換。那么dynamic_cast的存在還有什么意義呢？因為dynamic_cast提供了一個重要的特性：運行時類型檢查來保證轉換的安全性。

用static_cast轉換存在的危險

我們知道，一個基類指針不需要進行明確的轉換操作，就可以指向基類對象或者派生類對象。比如：

class Base{
  //…
};
class Derived{
  //…
};
int main{
  Base *p = new Base();//OK
  Base *p = new Derived();//OK
}

上面的兩種定義都是正確的，那么如果想反過來，讓一個子類指針指向父類對象呢？如下代碼：

class Base{
  //…
};
class Derived{
  //…
};
int main{
  Derived *p = new Base();//error
  Derived *p = static_cast<Derived*>(new Base());//OK
}

如果直接把Base類型的指針轉換為Derived類型的指針，那么編譯時會報錯。如果在轉換時加上static操作符則可以順利通過編譯。但是這種做法是十分危險的，在運行期時可能會出現(xiàn)一些難以預測和查找的錯誤。如下面代碼：

class Base{
  public:
    Base():m_b(4){};
    int m_b;
void m_funcB(){cout << "base" << endl;};
};
class Derived:public Base{
  public:
    Derived():m_d(3){};
    int m_d;
    void m_funcD(){cout << "derived" << endl;};
};
int main(){
  Derived* p = static_cast<Derived*>(new Base());
  cout << p->m_d << endl;
  p->m_funcD();
}

雖然p是Derived類型的指針，但是實際卻指向了Base對象，而Base對象不存在m_d這個數(shù)據成員，因此輸出的結果不可預測（在我的機子上一直輸出0）。正是這種不可預測才導致難以追蹤的錯誤，試想，如果執(zhí)行這段代碼會崩潰，那么還是比較還排查的，但是現(xiàn)在并不一定崩潰，只是執(zhí)行的結果和我們的預測不一致，可能將導致連環(huán)的邏輯錯誤，這就像給自己挖了一個坑或者定時炸彈。

但是很奇怪的一點是，執(zhí)行p->m_funcD()這一句后，居然可以打印出”derived”。這是怎么回事？m_funcD明明是類Derived的函數(shù)，而且類Base里并不存在這個函數(shù)，這個我們留在后面說明。

利用dynamic_cast保證轉換的安全

原則上，我們不應該讓子類指針指向父類的對象。但是如果寫下了上面這樣的代碼，我們希望可以有一種檢查機制可以幫助我們發(fā)現(xiàn)這個問題，這樣就可以避免對轉換后的指針進行操作，造成不可預料的后果。

C++是支持運行期類型識別的（RTTI），這種機制除了幫助我們實現(xiàn)多態(tài)，還能在類型轉換時進行安全檢查?；氐缴厦娴拇a，我們稍作修改：

class Base{
  public:
    Base():m_b(4){};
    int m_b;
    virtual void m_funcB(){cout << "base" << endl;};
};

class Derived:public Base{
  public:
    Derived():m_d(3){};
    int m_d;
    void m_funcD(){cout << "derived" << endl;};
};
int main(){
  Derived* p = dynamic_cast<Derived*>(new Base());
  cout << p->m_d << endl;
  p->m_funcD();
}

運行結果會是什么？程序崩潰了。原因就是我們執(zhí)行了p->m_d，而p這個時候是一個空指針。原因在于利用dynamic_cast進行類型轉換時會進行安全檢查，在這里我們將一個父類指針轉換為子類指針，這被認為是一個無效操作，因此返回NULL，因此p成了空指針。所以當我們利用dynamic_cast進行了轉換后，只要對得到的指針進行檢查，就可以知道轉換是否成功。static_cast則沒有提供這種檢查，這就是dynamic_cast比static_cast安全的原因。

現(xiàn)在稍微離開一下正題，如果把打印m_d這句注釋掉，執(zhí)行p->m_funcD()這一句后，發(fā)現(xiàn)還是能夠打印出”derived”。等我們總結dynamic_cast和static_cast的區(qū)別后就對這個現(xiàn)象進行討論。

dynamic_cast和static_cast的區(qū)別：

dynamic_cast可以實現(xiàn)運行期類型安全檢查，是一種更加安全的方法，但是僅僅對多態(tài)類型有效，而且只能用于指針或者引用類型的轉換上。static_cast則可應用與任何類型，而且不需要類型實現(xiàn)了多態(tài)。static_cast的應用更加廣泛，但是dynamic_cast更加強大和安全。

對象占用內存分析：

下面看一下我們兩次提到的現(xiàn)象：為什么通過一個實際指向了基類對象的子類指針調用子類的方法，既然沒有出現(xiàn)錯誤并且可以順利調用？

一個類無非就是包含兩種成員：數(shù)據和方法。那么當我們實例化出一個對象的時候，這個對象包含了哪些東西，實際占用的內存大小是多少？寫一段代碼試一試：

class Base{
  public:
    Base():m_b(4){};
    int m_b;
    virtual void m_funcB(){cout << "base" << endl;};
};
class Derived:public Base{
  public:
    Derived():m_d(3){};
    int m_d;
    void m_funcD(){cout << "derived" << endl;};
};
int main(){
  cout << sizeof(Base) << endl;  
  cout << sizeof(Derived) << endl;
}

打印出的結果分別是8和12。

那么一個類或者說對象占用的內存到底怎么計算呢？以Base為例，首先成員變量m_b占用了4個字節(jié)，其次，由于m_funcB是虛函數(shù)，因此要有一張?zhí)摵瘮?shù)表，其實就是一個指向表的指針，無論是什么類型的指針，占用的大小總是4字節(jié)，因此base占用了8個字節(jié)的大小。而Derived除了繼承了Base的成員m_b之外，也保存了虛函數(shù)表的地址，還有自己的成員變量m_d，所以占用了12個字節(jié)。

或者有人會問：構造函數(shù)呢？還有虛函數(shù)本身不是還有函數(shù)體嗎？難道不用計算進去？確實，類的函數(shù)是不會存儲在實例化出來的對象里的，試想，對于每個對象，函數(shù)實現(xiàn)都是一樣的，如果每實例化一個對象就存儲一次函數(shù)體，不是毫無必要并且對內存使用而言是極大的浪費？

函數(shù)編譯出來后是作為代碼的一部分放在代碼段中的，因此只要我們定義了Derived指針，無論這個實際指針指向什么對象，由于程序“事先”已經知道了這個方法屬于哪個類，只要指針的類型正確，都可以正確找到調用函數(shù)的入口。所以即使我們的代碼這么寫，也是可以正確運行的：

void * p2 = (int*)0;
Derived* p3= (Derived*)p2;
cout << p3->m_funcD() << endl;

不管把什么地址賦給p2，都能正確地執(zhí)行m_funcD函數(shù)。當然如果p3定義成其他類型，那么編譯就會出錯。

如果執(zhí)行以下代碼：

void * p2 = (int*)0;
Derived* p3= (Derived*)p2;
cout << p3->m_d << endl;

那么程序就會出現(xiàn)錯誤了，因為和成員函數(shù)不同，成員變量是每個對象都會在內存中用實際的內存地址存儲，所以說成員函數(shù)屬于類，成員變量屬于各自的對象。

以上就是小編為大家?guī)淼挠蓅tatic_cast和dynamic_cast到C++對象占用內存的全面分析全部內容了，希望大家多多支持腳本之家~

最新評論