溫故知新

 ----再談構造函數

作者：HolyFire

如果不知道構造函數的請先看一下《由始至終----構造與析構》，看過的我就不再多言，直接轉入話題。

定義一個類的的實例的時候，可以看到這樣的形式

classA a;//構造函數不需要參數

不需要參數的構造函數稱之為缺省構造函數。

不需要參數有兩種情況

1：構造函數沒有參數

2：構造函數有參數但可以不給出

class A{

public:

 A();//構造函數沒有參數

 A( int I = 10 );//構造函數的參數有缺省值，可以不用給出

};

這兩種情況都是缺省構造函數，但是由于缺省構造函數的特殊性（他是被自動調用的），編譯器無法判斷需要調用那一個，所以規定缺省構造函數只能有一個。

缺省構造函數的出現，意味著一個類型可以不依賴約束條件而被創建，就象一些細小的單元，質子，中子和電子，他們的有很大的類似性，不需要用條件來分辨他們被創建的信息。當然不需要用條件來分辨他們被創建的信息也包含了第二種情況，從流水線上生產的統一品種的產品很多都是用同一種方式的，那么創建他們的信息基本一致，也就是所符合第二種情況，參數可以采用缺省值。

這個例子我們可以舉一個例子，我們創建一個指針類的時候，常常把他指向的內容置為空值，這很容易理解，我們需要一個指針，但是現在還不知道指向誰，等到我們要使用它的時候，不一定是知道他是否指向過別的對象，為了簡化問題，一開始就將他置空，但是有時候我們需要用參數在創建的時候就給出指向的對象，特別是在產生臨時對象的時候尤為管用，那么，我們使用一個參數缺省值為空的缺省構造函數。

classA a( a1 );//構造函數有參數，而參數為一個相同的類型

這樣的構造函數叫做拷貝構造函數，意思就是將類一個實例的內容復制到新創建的實例中去，為什么要這么做呢。我們來研究一下。

我們平時使用基本類型的時候，可以使用賦值語句，將相同類型的某個對象的內容賦給另一個對象

int a = 3;

int b;

b = a; //這樣的話，b中就有和a一樣的內容了

還可在允許的情況下使用不同類型的賦值

int a = 3;

long b;

b = a;//這樣的話，b也能包含有和a一樣的內容了

我們在設計類的時候應該也是將一個類作為一個個體，一個類型來處理，而且在現實中這樣的行為也是存在的，一個人的個人資料可以寫在不同的紀錄簿上，一個軟件可以拷貝好幾份。

所以在面向對象編程中，這個問題不容忽視。

回到基本類型上，基本類型的處理編譯器完成了，在C++中很簡單，基本類型占用存儲空間是連續的，所以不管原來的內容是什么，只要照搬照抄就可以了，這種負值方式叫做逐位拷貝，簡稱位拷貝。

int a = 3;

int b;

假設：對象在內存中的存儲順序是先高后低，每個內存單元為1字節（BYTE）=8位（BIT）

//假設這是a(int)的存儲空間

0
3


//假設這是b(int)的存儲空間

?
?


b =a ;

//將a的內容拷貝到b中

0
3


 

?
?


//a

0
3


//b

0
3


我們設計的類在內存中也是連續的，使用這樣的拷貝方法會得到一個一模一樣的同類型實例。而且編譯器我們處理了這一件事（C++的編譯器真好，它能解決的事，就不用麻煩我們了），也就是說即使我們沒有定義拷貝構造函數，編譯器也會在需要使用的時候，自己產生一個拷貝構造函數，使用的方法就是位拷貝。但是這樣好嗎，使用這種方法產生的新類可以安全的工作嗎，應該有不少朋友已經產生了疑問。

什么時候可以讓編譯器自己處理拷貝構造函數。

#include <iostream>

using namespace std;

class A{

private:

int x;

int y;

int z;

public:

A():x(0),y(0),z(0){ }

A( int _x = 0 , int _y = 0 , int _z = 0 ):x(_x),y(_y),z(_z){ }

friend ostream& operator <<( ostream& , A const& );

};

ostream& operator <<( ostream& out , A const& arg )

{

out << "This is a Instance of A" << endl;

out << "Member Data x is : " << arg.x << endl;

out << "Member Data y is : " << arg.y << endl;

out << "Member Data z is : " << arg.z << endl;

return out;

}

void main()

{

A a( 1 , 12 ,123 );

A b(a);

cout << "This is a!" << endl;

cout << a << endl;

cout << "b is a copy of a!" << endl;

cout << b;

}

結果是：

This is a!

This is a Instance of A

Member Data x is : 1

Member Data y is : 12

Member Data z is : 123

b is a copy of a!

This is a Instance of A

Member Data x is : 1

Member Data y is : 12

Member Data z is : 123

可以看出，位拷貝得出的結果是正確的。

上面的例子中成員變量都是在編譯期間決定的，在內存中的位置也相對固定，如果成員變量的內容是在運行期間決定的呢，比如字符串成員變量，他需要在堆中動態分配內存。還能正常工作嗎，繼續看例子。

#include <iostream>

#include <string.h>

#include <mem.h>

using namespace std;

class A{

private:

 char * data;

public:

 A():data(NULL){ }

 A( char * _data ):data(NULL)

{

if( !_data )

 return;

int length = strlen(_data) +1;

data = new char[length];

memcpy( data , _data , length );

}

 ~A()

{

if( data )

 delete data;

}

 void Clear( void )

{

if( data )

 {

 memset( data , 0 , strlen( data ) );

 delete data;

 }

data = NULL;

}



 friend ostream& operator <<( ostream& , A const& );

};

ostream& operator <<( ostream& out , A const& arg )

{

 out << "This is a Instance of A" << endl;

 if( arg.data && *arg.data )

out << "Member Data data is : " << arg.data << endl;

 else

out << "Member Data data is : NULL" << endl;

 return out;

}

void main()

{

 A a( "abcdefg" );

 A b(a);

 cout << "This is a!" << endl;

 cout << a << endl;

 cout << "b is a copy of a!" << endl;

 cout << b << endl;

 a.Clear();

 cout << "Where a's mem clear!" << endl;

 cout << a;

 cout << "God! b's mem clear!" << endl;

 cout << b << endl;

}

結果是：

This is a!

This is a Instance of A

Member Data data is : abcdefg

b is a copy of a!

This is a Instance of A

Member Data data is : abcdefg

Where a's mem clear!

This is a Instance of A

Member Data data is : NULL

God! b's mem clear!

This is a Instance of A

Member Data data is : NULL//不！a中釋放了內存連帶著b的一起釋放掉了。

這是當然的由于位拷貝，b中的data只是將a中的data復制過來了而已，并沒有分配內存，拷貝字符串的內容。顯而易見，使用位拷貝不能滿足我們的要求，原來只需要簡單的將成員變量的值簡單的復制，這種我們稱之為：淺拷貝。現在我們需要處理對應成員變量，用其他方法來得到我們需要的結果，這種我們稱之為：深拷貝。

這樣我們就需要自己寫拷貝構造函數來實現深拷貝了。

#include <iostream.h>

#include <string.h>

#include <mem.h>

class A{

private:

 char * data;

public:

 A():data(NULL){ }

 A( char * _data ):data(NULL)

{

if( !_data )

 return;

int length = strlen(_data) +1;

data = new char[length];

memcpy( data , _data , length );

}

 A( A const& arg )

{

if( !arg.data )

 return;

int length = strlen(arg.data) +1;

data = new char[length];

memcpy( data , arg.data , length );

}

 ~A()

{

if( data )

 delete data;

}

 void Clear( void )

{

if( data )

 {

memset( data , 0 , strlen( data ) );

 delete data;

 }

data = NULL;

}

 friend ostream& operator <<( ostream& , A const& );

};

ostream& operator <<( ostream& out , A const& arg )

{

 out << "This is a Instance of A" << endl;

 if( arg.data && *arg.data )

out << "Member Data data is : " << arg.data << endl;

 else

out << "Member Data data is : NULL" << endl;

 return out;

}

void main()

{

 A a( "abcdefg" );

 A b(a);

 cout << "This is a!" << endl;

 cout << a << endl;

 cout << "b is a copy of a!" << endl;

 cout << b << endl;

 a.Clear();

 cout << "Where a's mem clear!" << endl;

 cout << a;

 cout << "Good! b's mem not clear!" << endl;

 cout << b << endl;

}

結果是：

This is a!

This is a Instance of A

Member Data data is : abcdefg

b is a copy of a!

This is a Instance of A

Member Data data is : abcdefg

Where a's mem clear!

This is a Instance of A

Member Data data is : NULL

Good! b's mem not clear!

This is a Instance of A

Member Data data is : abcdefg //哈哈，這正是我想得到的結果。

如果能使用位拷貝，盡量讓編譯器自己用位拷貝的方式處理，這樣會提高效率。但是一定要謹慎，不然會產生不可預料的結果，如果你的類中有一個成員變量也是類，它使用了深拷貝，那么你也一定要使用深拷貝。

另外，我在《白馬非馬----繼承》中說到，一個類型的的派生類是該類型的一種。那么。

class A;

class B: public A{

};

B b;

A a(b);

這樣的形式是正確的。事實上，b先切片退化成一個臨時變量tempb，類型是class A，有關A的部分原封不動的保留下來，然后使用A a(tempb)這樣的方式成功的調用了。

拷貝構造函數并非可有可無！不能用其他函數來替代

看這樣的例子

void function( A a);

在函數調用的時候按值傳遞參數，那么將在棧里產生一個class A的臨時變量，如果沒有拷貝構造函數，這個過程就無法自動完成，如果沒用設計好淺拷貝或深拷貝，那么可能得不到正確結果。如果拷貝構造函數正確，那么我們可以輕松的獲得我們想要的結果----按值傳遞的參數在函數執行后不受影響。

classA a = a1;//拷貝構造函數

事實上就是這樣的形式。

ClassA a(a1);//可以改成這種形式