|
由始至終
----構造與析構
作者：HolyFire
我們在平時的生活中一般會總結出一些規(guī)律，早上起床會刷牙洗臉，晚上會洗澡睡覺，這些都成了慣例。使用瓶裝調味品時先將瓶蓋打開，用完后將瓶蓋蓋上。這是一種好習慣。但是有些人不同，他們往往偷懶，一個常常不刷牙不洗臉不洗澡的人會有體味，東西放得亂七八糟的人生房間很不整潔。這些都是我們不希望看到的。當然編程中我們也不希望代碼亂七八糟。
使用一個未初始化的變量簡直就是災難，使用一個未初始化的指針將導致崩潰。這是我的忠告。在C++中初始化不會有附加的效果，不會降低效率，我們要做的是養(yǎng)成好習慣，產(chǎn)生一個對象的時候就將它初始化。
對于
Object.Init();
Object.Free();
這樣的調用并不是很困難，要記住他也不是難事，但是誰都不能保證他永遠不會忘記，更糟糕的是
Object.Init();
Object.Free();
沒有配對使用
Object.Init();
Object.Free();
Object.Free();
或
Object.Init();
Object.Init();
Object.Free();
會帶來什么樣的結果，誰也不知道，而且這樣的錯誤，編譯器不會報錯。這是多么可怕的錯誤，一個程序員最怕遇上的就是這樣的邏輯錯誤，它可能為了找這樣的一個錯誤花上一整天時間。
讓我們看看有什么好的辦法。
一個對象按時間來分析，一般有三個階段，出生，活動，死亡。與我們要做的有什么相關之處呢，初始化，運行，釋放。很好，對照一下，我們發(fā)現(xiàn)在對象出生的時候初始化，死亡的時候釋放，如果這一切能用這樣的機制來操作，我們就再也不用擔心會由于忘記或錯誤的使用帶來麻煩了。
C++里就提供了這樣的機制。使用他有個約定
class Object{
public:
Object(); //與類同名的函數(shù)，該函數(shù)沒有返回值，叫做構造函數(shù)
~Object();//類似的，在構造函數(shù)名前加一個取反符號，叫做析構函數(shù)
};
構造函數(shù)將在對象產(chǎn)生的時候調用
析構函數(shù)將在對象銷毀的時候調用
調用的過程和實現(xiàn)方法由編譯器完成，我們只要記住他們調用的時間就行了，而且他們的調用是自動完成的，不需要我們控制。
#include <iostream>
using namespace std;
class Object{
public:
Object(){ cout << "Object ON!" << endl; }
~Object(){ cout << "Object OFF!" << endl; }
};
void main()
{
Object o;
}
運行結果
Object ON!
Object OFF!
構在函數(shù)和析構函數(shù)確實的執(zhí)行了
現(xiàn)在我們來一個應用的例子
一個字符串類，它需要保存字符串的內(nèi)容，但是它不知道字符串的大小，那么設計這個字符串類的時候，保存字符串的成員變量就不能用固定大小的數(shù)組，而是用可以間接操作數(shù)組的指針。
#include <iostream>
#include <string.h>
using namespace std;
class string{
private:
char * data;
public:
string(){ data = NULL; }
string( char * str )
{
cout << "Copy string: " << str << endl;
data = new char[ strlen(str) + 1 ];
memcpy( data , str , strlen(str) + 1 );
}
char * Data(){ return data; }
~string()
{
if( data )
{
cout << "Free string: " << data << endl;
delete data;
}
}
};
void main()
{
{
string s("abcd");
cout <<"Show String: " << s.Data() <<endl;
}
cin.get();
}
Copy string: abcd //執(zhí)行了string::string( char * str ) 構造函數(shù)
Show String: abcd
Free string: abcd //由于在{}中產(chǎn)成的對象是臨時對象，它的生命期在}后就結束了，所以string::~string() 析構函數(shù)被調用
申請內(nèi)存和釋放內(nèi)存的操作自動完成了，構造函數(shù)和析構函數(shù)的目的在于一個類可以象普通類型一樣初始化和釋放，從而保證了封裝。
上面的例子有兩個構造函數(shù)，這么什么大不了的，我們看過《面面俱到----重載》得都知道，重載的把戲。
要注意的是構造函數(shù)可以有參數(shù)，在繼承中如何處理呢。
class mystring : public string{
public:
mystring( char * str ):string( str ){ }
}
mystring( char * str ):string( str )
記住這樣的形式，給自己的父類傳遞函數(shù)就用這樣的書寫格式，這是一個約定。
構造函數(shù)后面加上一個:表示后面是一個初始化序列，說它是一個序列是因為它可以初始化多個成員變量，在初始化序列里調用向父類傳遞參數(shù)是為了保證類的產(chǎn)生的順序，先產(chǎn)生父類，然后是子類。使用初始化有個好處就是可以提高效率。
string(){ data = NULL; }
可以改寫成
string():data(NULL){ }
他的作用是產(chǎn)生成員變量char * data時將他的值置為NULL。從而少了data = NULL;這步操作。
注意，這里構造和析構有一個順序問題，就是構造時應該從基類開始按繼承的層次順序調用，析構的時候順序正好相反。這樣處理是因為，子類可能在構造函數(shù)里使用父類的成員變量，如果父類還沒有創(chuàng)建，那就會有問題，而析構的時候，如果父類先析構，也會有這樣的問題。
析構函數(shù)還有一個能否正確運行的問題。
#include <iostream>
using namespace std;
class One{
public:
One(){ cout << "One ON!" << endl; }
~One(){ cout << "One OFF!" << endl; }
};
class Two : public One{
public:
Two(){ cout << "Two ON!" << endl; }
~Two(){ cout << "Two OFF!" << endl; }
};
class Three : public Two{
public:
Three(){ cout << "Three ON!" << endl; }
~Three(){ cout << "Three OFF!" << endl; }
};
void main()
{
Three three;
}
運行結果
One ON!
Two ON!
Three ON!
Three OFF!
Two OFF!
One OFF!
正確
void main()
{
Three * three = new Three;
delete three;
}
運行結果
One ON!
Two ON!
Three ON!
Three OFF!
Two OFF!
One OFF!
正確
void main()
{
One * three = new Three;
delete three;
}
運行結果
One ON!
Two ON!
Three ON!
One OFF!
不好了，Two和Three的析構都沒有運行，怎么會這樣，原來One * three指出了指針指向的是一個One類的對象。如何得到正確的結果呢，如果能讓One類記住被繼承后的變化就好了。
對了！虛函數(shù)，在《后入為主----虛函數(shù)》中可以知道，虛函數(shù)有這個特性，不信試試看。
class One{
public:
One(){ cout << "One ON!" << endl; }
virtual ~One(){ cout << "One OFF!" << endl; }
};
void main()
{
One * three = new Three;
delete three;
}
運行結果
One ON!
Two ON!
Three ON!
Three OFF!
Two OFF!
One OFF!
正確
這個特點很重要，我們要牢牢記住，我們稱這種方法為“虛析構”，在多態(tài)里運用非常廣泛，也是編寫可復用代碼的一個重要技巧。
構造和析構的作用機制就是自動化，簡化編程的復雜度。還有要記住的是，在一個類的構造函數(shù)里分配了的資源盡量要記得在該類的析構函數(shù)里釋放，當然也允許提前釋放，你可以在析構函數(shù)里判斷它是否已經(jīng)釋放，如果沒有就釋放。這就是----由始至終，它間接的描述了一個對象的生和死（記住這一點很重要，因為我以后會講到如何運用這個特性控制對象的生死）。
|
