探索C++对象模型
一．基本概念
先來看看棧。棧，一般用于存放局部變量或?qū)ο?#xff0c;如我們在函數(shù)定義中用類似下面語句聲明的對象：
Type stack_object ;
stack_object便是一個棧對象，它的生命期是從定義點開始，當所在函數(shù)返回時，生命結(jié)束。
另外，幾乎所有的臨時對象都是棧對象。比如，下面的函數(shù)定義：
Type fun（Type object） ;
這個函數(shù)至少產(chǎn)生兩個臨時對象，首先，參數(shù)是按值傳遞的，所以會調(diào)用拷貝構(gòu)造函數(shù)生成一個臨時對象object_copy1，在函數(shù)內(nèi)部使用的不是使用的不是object，而是object_copy1，自然，object_copy1是一個棧對象，它在函數(shù)返回時被釋放；還有這個函數(shù)是值返回的，在函數(shù)返回時，如果我們不考慮返回值優(yōu)化（NRV），那么也會產(chǎn)生一個臨時對象object_copy2，這個臨時對象會在函數(shù)返回后一段時間內(nèi)被釋放。比如某個函數(shù)中有如下代碼：
Type tt ,result ; //生成兩個棧對象
tt = fun（tt） ; //函數(shù)返回時，生成的是一個臨時對象object_copy2
上面的第二個語句的執(zhí)行情況是這樣的，首先函數(shù)fun返回時生成一個臨時對象object_copy2，然后再調(diào)用賦值運算符執(zhí)行
tt = object_copy2 ; //調(diào)用賦值運算符
看到了嗎？編譯器在我們毫無知覺的情況下，為我們生成了這么多臨時對象，而生成這些臨時對象的時間和空間的開銷可能是很大的，所以，你也許明白了，為什么對于“大”對象最好用const引用傳遞代替按值進行函數(shù)參數(shù)傳遞了。
接下來，看看堆。堆，又叫自由存儲區(qū)，它是在程序執(zhí)行的過程中動態(tài)分配的，所以它最大的特性就是動態(tài)性。在C++中，所有堆對象的創(chuàng)建和銷毀都要由程序員負責，所以，如果處理不好，就會發(fā)生內(nèi)存問題。如果分配了堆對象，卻忘記了釋放，就會產(chǎn)生內(nèi)存泄漏；而如果已釋放了對象，卻沒有將相應的指針置為NULL，該指針就是所謂的“懸掛指針”，再度使用此指針時，就會出現(xiàn)非法訪問，嚴重時就導致程序崩潰。
那么，C++中是怎樣分配堆對象的？唯一的方法就是用new（當然，用類malloc指令也可獲得C式堆內(nèi)存），只要使用new，就會在堆中分配一塊內(nèi)存，并且返回指向該堆對象的指針。
再來看看靜態(tài)存儲區(qū)。所有的靜態(tài)對象、全局對象都于靜態(tài)存儲區(qū)分配。關(guān)于全局對象，是在main()函數(shù)執(zhí)行前就分配好了的。其實，在main()函數(shù)中的顯示代碼執(zhí)行之前，會調(diào)用一個由編譯器生成的_main()函數(shù)，而_main()函數(shù)會進行所有全局對象的的構(gòu)造及初始化工作。而在main()函數(shù)結(jié)束之前，會調(diào)用由編譯器生成的exit函數(shù)，來釋放所有的全局對象。比如下面的代碼：
void main（void）
{
… …// 顯式代碼
}
實際上，被轉(zhuǎn)化成這樣：
void main（void）
{
_main（）; //隱式代碼，由編譯器產(chǎn)生，用以構(gòu)造所有全局對象? (勿寧說此段代碼在main之前而不是其中)
… … // 顯式代碼
… …
exit（） ; // 隱式代碼，由編譯器產(chǎn)生，用以釋放所有全局對象
}
所以，知道了這個之后，便可以由此引出一些技巧，如，假設我們要在main()函數(shù)執(zhí)行之前做某些準備工作，那么我們可以將這些準備工作寫到一個自定義的全局對象的構(gòu)造函數(shù)中，這樣，在main()函數(shù)的顯式代碼執(zhí)行之前，這個全局對象的構(gòu)造函數(shù)會被調(diào)用，執(zhí)行預期的動作，這樣就達到了我們的目的。 剛才講的是靜態(tài)存儲區(qū)中的全局對象，那么，局部靜態(tài)對象了？局部靜態(tài)對象通常也是在函數(shù)中定義的，就像棧對象一樣，只不過，其前面多了個static關(guān)鍵字。局部靜態(tài)對象的生命期是從其所在函數(shù)第一次被調(diào)用，更確切地說，是當?shù)谝淮螆?zhí)行到該靜態(tài)對象的聲明代碼時，產(chǎn)生該靜態(tài)局部對象，直到整個程序結(jié)束時，才銷毀該對象。
還有一種靜態(tài)對象，那就是它作為class的靜態(tài)成員。考慮這種情況時，就牽涉了一些較復雜的問題。
第一個問題是class的靜態(tài)成員對象(非靜態(tài)方法#add)的生命期，class的靜態(tài)成員對象隨著第一個class object的產(chǎn)生而產(chǎn)生，在整個程序結(jié)束時消亡。也就是有這樣的情況存在，在程序中我們定義了一個class，該類中有一個靜態(tài)對象作為成員，(但是我們使用某個類的靜態(tài)方法時都是直接使用classA::method()這是否意味著在此刻就產(chǎn)生了一個classA對象呢?思考后得出為沒產(chǎn)生，靜態(tài)方法不需要一定有一個對象（有對象就會有成員變量，靜態(tài)函數(shù)的函數(shù)代碼是生成了，但沒有成員變量，所以沒產(chǎn)生對象）。#add)但是在程序執(zhí)行過程中，如果我們沒有創(chuàng)建任何一個該class object，那么也就不會產(chǎn)生該class所包含的那個靜態(tài)對象。還有，如果創(chuàng)建了多個class object，那么所有這些object都共享那個靜態(tài)對象成員。
第二個問題是，當出現(xiàn)下列情況時：
class Base
{
public:
static Type s_object ;
}
class Derived1 : public Base / / 公共繼承
{
… …// other data
}
class Derived2 : public Base / / 公共繼承
{
… …// other data
}
Base example ;
Derivde1 example1 ;
Derivde2 example2 ;
example.s_object = …… ;
example1.s_object = …… ;
example2.s_object = …… ;
請注意上面標為黑體的三條語句，它們所訪問的s_object是同一個對象嗎？答案是肯定的，它們的確是指向同一個對象，這聽起來不像是真的，是嗎？但這是事實，你可以自己寫段簡單的代碼驗證一下。我要做的是來解釋為什么會這樣？我們知道，當一個類比如Derived1，從另一個類比如Base繼承時，那么，可以看作一個Derived1對象中含有一個Base型的對象，這就是一個subobject。一個Derived1對象的大致內(nèi)存布局如下：
讓我們想想，當我們將一個Derived1型的對象傳給一個接受非引用Base型參數(shù)的函數(shù)時會發(fā)生切割，那么是怎么切割的呢？相信現(xiàn)在你已經(jīng)知道了，那就是僅僅取出了Derived1型的對象中的subobject，而忽略了所有Derived1自定義的其它數(shù)據(jù)成員，然后將這個subobject傳遞給函數(shù)（實際上，函數(shù)中使用的是這個subobject的拷貝）。
所有繼承Base類的派生類的對象都含有一個Base型的subobject（這是能用Base型指針指向一個Derived1對象的關(guān)鍵所在，自然也是多態(tài)的關(guān)鍵了），而所有的subobject和所有Base型的對象都共用同一個s_object對象，自然，從Base類派生的整個繼承體系中的類的實例都會共用同一個s_object對象了。上面提到的example、example1、example2的對象布局如下圖所示：
?
二．三種內(nèi)存對象的比較
棧對象的優(yōu)勢是在適當?shù)臅r候自動生成，又在適當?shù)臅r候自動銷毀，不需要程序員操心；而且棧對象的創(chuàng)建速度一般較堆對象快，因為分配堆對象時，會調(diào)用operator new操作，operator new會采用某種內(nèi)存空間搜索算法，而該搜索過程可能是很費時間的，產(chǎn)生棧對象則沒有這么麻煩，它僅僅需要移動棧頂指針就可以了。但是要注意的是，通常棧空間容量比較小，一般是1MB～2MB，所以體積比較大的對象不適合在棧中分配。特別要注意遞歸函數(shù)中最好不要使用棧對象，因為隨著遞歸調(diào)用深度的增加，所需的棧空間也會線性增加，當所需棧空間不夠時，便會導致棧溢出，這樣就會產(chǎn)生運行時錯誤。
堆對象，其產(chǎn)生時刻和銷毀時刻都要程序員精確定義，也就是說，程序員對堆對象的生命具有完全的控制權(quán)。我們常常需要這樣的對象，比如，我們需要創(chuàng)建一個對象，能夠被多個函數(shù)所訪問，但是又不想使其成為全局的，那么這個時候創(chuàng)建一個堆對象無疑是良好的選擇，然后在各個函數(shù)之間傳遞這個堆對象的指針，便可以實現(xiàn)對該對象的共享。另外，相比于棧空間，堆的容量要大得多。實際上，當物理內(nèi)存不夠時，如果這時還需要生成新的堆對象，通常不會產(chǎn)生運行時錯誤，而是系統(tǒng)會使用虛擬內(nèi)存來擴展實際的物理內(nèi)存。
接下來看看static對象。
首先是全局對象。全局對象為類間通信和函數(shù)間通信提供了一種最簡單的方式，雖然這種方式并不優(yōu)雅。一般而言，在完全的面向?qū)ο笳Z言中，是不存在全局對象的，比如C#，因為全局對象意味著不安全和高耦合，在程序中過多地使用全局對象將大大降低程序的健壯性、穩(wěn)定性、可維護性和可復用性。C++也完全可以剔除全局對象，但是最終沒有，我想原因之一是為了兼容C。
其次是類的靜態(tài)成員，上面已經(jīng)提到，基類及其派生類的所有對象都共享這個靜態(tài)成員對象，所以當需要在這些class之間或這些class objects之間進行數(shù)據(jù)共享或通信時，這樣的靜態(tài)成員無疑是很好的選擇。
接著是靜態(tài)局部對象，主要可用于保存該對象所在函數(shù)被屢次調(diào)用期間的中間狀態(tài)，其中一個最顯著的例子就是遞歸函數(shù)，我們都知道遞歸函數(shù)是自己調(diào)用自己的函數(shù)，如果在遞歸函數(shù)中定義一個nonstatic局部對象，那么當遞歸次數(shù)相當大時，所產(chǎn)生的開銷也是巨大的。這是因為nonstatic局部對象是棧對象，每遞歸調(diào)用一次，就會產(chǎn)生一個這樣的對象，每返回一次，就會釋放這個對象，而且，這樣的對象只局限于當前調(diào)用層，對于更深入的嵌套層和更淺露的外層，都是不可見的。每個層都有自己的局部對象和參數(shù)。
在遞歸函數(shù)設計中，可以使用static對象替代nonstatic局部對象（即棧對象），這不僅可以減少每次遞歸調(diào)用和返回時產(chǎn)生和釋放nonstatic對象的開銷，而且static對象還可以保存遞歸調(diào)用的中間狀態(tài)，并且可為各個調(diào)用層所訪問。
?
三．使用棧對象的意外收獲
前面已經(jīng)介紹到，棧對象是在適當?shù)臅r候創(chuàng)建，然后在適當?shù)臅r候自動釋放的，也就是棧對象有自動管理功能。那么棧對象會在什么會自動釋放了？第一，在其生命期結(jié)束的時候；第二，在其所在的函數(shù)發(fā)生異常的時候。你也許說，這些都很正常啊，沒什么大不了的。是的，沒什么大不了的。但是只要我們再深入一點點，也許就有意外的收獲了。
棧對象，自動釋放時，會調(diào)用它自己的析構(gòu)函數(shù)。如果我們在棧對象中封裝資源，而且在棧對象的析構(gòu)函數(shù)中執(zhí)行釋放資源的動作，那么就會使資源泄漏的概率大大降低，因為棧對象可以自動的釋放資源，即使在所在函數(shù)發(fā)生異常的時候。實際的過程是這樣的：函數(shù)拋出異常時，會發(fā)生所謂的stack_unwinding（堆棧回滾），即堆棧會展開，由于是棧對象，自然存在于棧中，所以在堆棧回滾的過程中，棧對象的析構(gòu)函數(shù)會被執(zhí)行，從而釋放其所封裝的資源。除非，除非在析構(gòu)函數(shù)執(zhí)行的過程中再次拋出異常――而這種可能性是很小的，所以用棧對象封裝資源是比較安全的。基于此認識，我們就可以創(chuàng)建一個自己的句柄或代理來封裝資源了。智能指針（auto_ptr）中就使用了這種技術(shù)。在有這種需要的時候，我們就希望我們的資源封裝類只能在棧中創(chuàng)建，也就是要限制在堆中創(chuàng)建該資源封裝類的實例。
?
四．只能產(chǎn)生棧對象
上面已經(jīng)提到，你決定禁止產(chǎn)生某種類型的堆對象，這時你可以自己創(chuàng)建一個資源封裝類，該類對象只能在棧中產(chǎn)生，這樣就能在異常的情況下自動釋放封裝的資源。
那么怎樣禁止產(chǎn)生堆對象了？我們已經(jīng)知道，產(chǎn)生堆對象的唯一方法是使用new操作，如果我們禁止使用new不就行了么。再進一步，new操作執(zhí)行時會調(diào)用operator new，而operator new是可以重載的。方法有了，就是使new operator為private，為了對稱，最好將operator delete也重載為private。現(xiàn)在，你也許又有疑問了,難道創(chuàng)建棧對象不需要調(diào)用new嗎？是的，不需要，因為創(chuàng)建棧對象不需要搜索內(nèi)存，而是直接調(diào)整堆棧指針，將對象壓棧，而operator new的主要任務是搜索合適的堆內(nèi)存，為堆對象分配空間，這在上面已經(jīng)提到過了。好，讓我們看看下面的示例代碼：
#include <stdlib.h> //需要用到C式內(nèi)存分配函數(shù)
class Resource ; //代表需要被封裝的資源類
class NoHashObject
{
private:
Resource* ptr ;//指向被封裝的資源
... ... //其它數(shù)據(jù)成員
void* operator new(size_t size) //非嚴格實現(xiàn)，僅作示意之用
{
return malloc(size) ;
}
void operator delete(void* pp) //非嚴格實現(xiàn)，僅作示意之用
{
free(pp) ;
}
public:
NoHashObject()
{
//此處可以獲得需要封裝的資源，并讓ptr指針指向該資源
ptr = new Resource() ;
}
~NoHashObject()
{
delete ptr ; //釋放封裝的資源
}
};
NoHashObject現(xiàn)在就是一個禁止堆對象的類了，如果你寫下如下代碼：
NoHashObject* fp = new NoHashObject() ; //編譯期錯誤！
delete fp ;
上面代碼會產(chǎn)生編譯期錯誤。好了，現(xiàn)在你已經(jīng)知道了如何設計一個禁止堆對象的類了，你也許和我一樣有這樣的疑問，難道在類NoHashObject的定義不能改變的情況下，就一定不能產(chǎn)生該類型的堆對象了嗎？不，還是有辦法的，我稱之為“暴力破解法”。C++是如此地強大，強大到你可以用它做你想做的任何事情。這里主要用到的是技巧是指針類型的強制轉(zhuǎn)換。
void main(void)
{
char* temp = new char[sizeof(NoHashObject)] ;
//強制類型轉(zhuǎn)換，現(xiàn)在ptr是一個指向NoHashObject對象的指針
NoHashObject* obj_ptr = (NoHashObject*)temp ;
temp = NULL ; //防止通過temp指針修改NoHashObject對象
//再一次強制類型轉(zhuǎn)換，讓rp指針指向堆中NoHashObject對象的ptr成員
Resource* rp = (Resource*)obj_ptr ;
//初始化obj_ptr指向的NoHashObject對象的ptr成員
rp = new Resource() ;
//現(xiàn)在可以通過使用obj_ptr指針使用堆中的NoHashObject對象成員了
... ...
delete rp ;//釋放資源
temp = (char*)obj_ptr ;
obj_ptr = NULL ;//防止懸掛指針產(chǎn)生
delete [] temp ;//釋放NoHashObject對象所占的堆空間。
}
上面的實現(xiàn)是麻煩的，而且這種實現(xiàn)方式幾乎不會在實踐中使用，但是我還是寫出來路，因為理解它，對于我們理解C++內(nèi)存對象是有好處的。對于上面的這么多強制類型轉(zhuǎn)換，其最根本的是什么了？我們可以這樣理解：
某塊內(nèi)存中的數(shù)據(jù)是不變的，而類型就是我們戴上的眼鏡，當我們戴上一種眼鏡后，我們就會用對應的類型來解釋內(nèi)存中的數(shù)據(jù)，這樣不同的解釋就得到了不同的信息。
所謂強制類型轉(zhuǎn)換實際上就是換上另一副眼鏡后再來看同樣的那塊內(nèi)存數(shù)據(jù)。
另外要提醒的是，不同的編譯器對對象的成員數(shù)據(jù)的布局安排可能是不一樣的，比如，大多數(shù)編譯器將NoHashObject的ptr指針成員安排在對象空間的頭4個字節(jié)，這樣才會保證下面這條語句的轉(zhuǎn)換動作像我們預期的那樣執(zhí)行：
Resource* rp = (Resource*)obj_ptr ;
但是，并不一定所有的編譯器都是如此。
既然我們可以禁止產(chǎn)生某種類型的堆對象，那么可以設計一個類，使之不能產(chǎn)生棧對象嗎？當然可以。
?
五．只能產(chǎn)生堆對象
前面已經(jīng)提到了，創(chuàng)建棧對象時會移動棧頂指針以“挪出”適當大小的空間，然后在這個空間上直接調(diào)用對應的構(gòu)造函數(shù)以形成一個棧對象，而當函數(shù)返回時，會調(diào)用其析構(gòu)函數(shù)釋放這個對象，然后再調(diào)整棧頂指針收回那塊棧內(nèi)存。在這個過程中是不需要operator new/delete操作的，所以將operator new/delete設置為private不能達到目的。當然從上面的敘述中，你也許已經(jīng)想到了：將構(gòu)造函數(shù)或析構(gòu)函數(shù)設為私有的，這樣系統(tǒng)就不能調(diào)用構(gòu)造/析構(gòu)函數(shù)了，當然就不能在棧中生成對象了。
這樣的確可以，而且我也打算采用這種方案。但是在此之前，有一點需要考慮清楚,那就是，如果我們將構(gòu)造函數(shù)設置為私有，那么我們也就不能用new來直接產(chǎn)生堆對象了，因為new在為對象分配空間后也會調(diào)用它的構(gòu)造函數(shù)啊。所以，我打算只將析構(gòu)函數(shù)設置為private。再進一步，將析構(gòu)函數(shù)設為private除了會限制棧對象生成外，還有其它影響嗎？是的，這還會限制繼承。
如果一個類不打算作為基類，通常采用的方案就是將其析構(gòu)函數(shù)聲明為private。
為了限制棧對象，卻不限制繼承，我們可以將析構(gòu)函數(shù)聲明為protected，這樣就兩全其美了。如下代碼所示：
class NoStackObject
{
protected:
~NoStackObject() { }
public:
void destroy()
{
delete this ;//調(diào)用保護析構(gòu)函數(shù)
}
};
接著，可以像這樣使用NoStackObject類：
NoStackObject* hash_ptr = new NoStackObject() ;
... ... //對hash_ptr指向的對象進行操作
hash_ptr->destroy() ;
呵呵，是不是覺得有點怪怪的，我們用new創(chuàng)建一個對象，卻不是用delete去刪除它，而是要用destroy方法。很顯然，用戶是不習慣這種怪異的使用方式的。所以，我決定將構(gòu)造函數(shù)也設為private或protected。這又回到了上面曾試圖避免的問題，即不用new，那么該用什么方式來生成一個對象了？我們可以用間接的辦法完成，即讓這個類提供一個static成員函數(shù)專門用于產(chǎn)生該類型的堆對象。（設計模式中的singleton模式就可以用這種方式實現(xiàn)。）讓我們來看看：
class NoStackObject
{
protected:
NoStackObject() { }
~NoStackObject() { }
public:
static NoStackObject* creatInstance()
{
return new NoStackObject() ;//調(diào)用保護的構(gòu)造函數(shù)
}
void destroy()
{
delete this ;//調(diào)用保護的析構(gòu)函數(shù)
}
};
現(xiàn)在可以這樣使用NoStackObject類了：
NoStackObject* hash_ptr = NoStackObject::creatInstance() ;
... ... //對hash_ptr指向的對象進行操作
hash_ptr->destroy() ;
hash_ptr = NULL ; //防止使用懸掛指針
現(xiàn)在感覺是不是好多了，生成對象和釋放對象的操作一致了。
ok，講到這里，已經(jīng)涉及了較多的東西，如果要把內(nèi)存對象講得更深入更全面，那可能需要寫成一本書了，而就我自己的功力而言，可能是很難完全把握的。如果上面所寫的能使你有所收獲或啟發(fā)，我就滿足了。如果你要更進一步去了解內(nèi)存對象方面的知識，那么我可以推薦你看看《深入探索C++對象模型》這本書
?
?
總結(jié)
- 上一篇： Spring 更好地处理 Struts
- 下一篇： oracle创建表空间.创建用户.创建表