在C++中，構造函數是一個在構件對象的時候調用的特殊的函數，其目的是對對象進行初始化的工作，從而使對象被使用之前可以處于一種合理的狀態。但是，構造函數的設計并不完美，甚至有些不合理的特性。比如說，限定構造函數名稱與類的名稱相同的條件。這些特性在構造C++編譯器的時候是值得引起注意的。還有，在今后C++的標準修訂或者制定其他面向對象的設計語言時候應當避免這些特性。這里也提出了一些解決的方案。

[[21117]] 

　　C++中，任何類都有一個(至少有一個)構造函數，甚至在沒有構造函數被聲明的時候亦是如此。在對象被聲明的時候，或者被動態生成的時候，這些構造函數就會被調用。構造函數做了許多不可見的工作，即使構造函數中沒有任何代碼，這些工作包括對對象的內存分配和通過賦值的方式對成員進行初始化。構造函數的名稱必須與類的名稱相同，但是可以有許多不同的重載版本來提供，通過參數類型來區分構造函數的版本。構造函數可以顯式的通過用戶代碼來調用，或者當代碼不存在是通過編譯程序來隱式插入。當然，顯式地通過代碼調用是推薦的方法，因為隱式調用的效果可能不是我們所預料的，特別是在處理動態內存分配方面。代碼通過參數來調用唯一的構造函數。構造函數沒有返回值，盡管在函數體中可以又返回語句。每個構造函數可以以不同的方式來實例化一個對象，因為每個類都有構造函數，至少也是缺省構造函數，所以每個對象在使用之前都相應的使用構造函數。

　　因為構造函數是一種函數，所以他的可見性無非是三種public、private、protected。通常，構造函數都被聲明為public型。如果構造函數被聲明為private或protected，就限制了對象的實例化。這在阻止類被其他人實例化的方面很有效。構造函數中可以有任何C++的語句，比如，一條打印語句，可以被加入到構造函數中來表明調用的位置。

#p#

　　構造函數的類型

　　C++中構造函數有許多種類型，最常用的式缺省構造函數和拷貝構造函數，也存在一些不常用的構造函數。下面介紹了四種不同的構造函數。

　　1、缺省構造函數

　　缺省構造函數是沒有參數的函數。另外，缺省構造函數也可以在參數列表中以參數缺省值的方式聲明。缺省構造函數的作用是把對象初始化為缺省的狀態。如果在類中沒有顯式定義構造函數，那么編譯器會自動的隱式創建一個，這個隱式創建的構造函數和一個空的構造函數很相像。他除了產生對象的實例以外什么工作都不做。在許多情況下，缺省構造函數都會被自動的調用，例如在一個對象被聲明的時候，就會引起缺省構造函數的調用。

　　2、拷貝構造函數

　　拷貝構造函數，經常被稱作X(X&)，是一種特殊的構造函數，他由編譯器調用來完成一些基于同一類的其他對象的構件及初始化。它的唯一的一個參數(對象的引用)是不可變的(因為是const型的)。這個函數經常用在函數調用期間于用戶定義類型的值傳遞及返回。拷貝構造函數要調用基類的拷貝構造函數和成員函數。如果可以的話，它將用常量方式調用，另外，也可以用非常量方式調用。

　　在C++中，下面三種對象需要拷貝的情況。因此，拷貝構造函數將會被調用。

　　1). 一個對象以值傳遞的方式傳入函數體

　　2). 一個對象以值傳遞的方式從函數返回

　　3). 一個對象需要通過另外一個對象進行初始化

　　以上的情況需要拷貝構造函數的調用。如果在前兩種情況不使用拷貝構造函數的時候，就會導致一個指針指向已經被刪除的內存空間。對于第三種情況來說，初始化和賦值的不同含義是構造函數調用的原因。事實上，拷貝構造函數是由普通構造函數和賦值操作賦共同實現的。描述拷貝構造函數和賦值運算符的異同的參考資料有很多。

　　拷貝構造函數不可以改變它所引用的對象，其原因如下：當一個對象以傳遞值的方式傳一個函數的時候，拷貝構造函數自動的被調用來生成函數中的對象。如果一個對象是被傳入自己的拷貝構造函數，它的拷貝構造函數將會被調用來拷貝這個對象這樣復制才可以傳入它自己的拷貝構造函數，這會導致無限循環。

　　除了當對象傳入函數的時候被隱式調用以外，拷貝構造函數在對象被函數返回的時候也同樣的被調用。換句話說，你從函數返回得到的只是對象的一份拷貝。但是同樣的，拷貝構造函數被正確的調用了，你不必擔心。

　　如果在類中沒有顯式的聲明一個拷貝構造函數，那么，編譯器會私下里為你制定一個函數來進行對象之間的位拷貝(bitwise copy)。這個隱含的拷貝構造函數簡單的關聯了所有的類成員。許多作者都會提及這個默認的拷貝構造函數。注意到這個隱式的拷貝構造函數和顯式聲明的拷貝構造函數的不同在于對于成員的關聯方式。顯式聲明的拷貝構造函數關聯的只是被實例化的類成員的缺省構造函數除非另外一個構造函數在類初始化或者在構造列表的時候被調用。

　　拷貝構造函數是程序更加有效率，因為它不用再構造一個對象的時候改變構造函數的參數列表。設計拷貝構造函數是一個良好的風格，即使是編譯系統提供的幫助你申請內存默認拷貝構造函數。事實上，默認拷貝構造函數可以應付許多情況。

　　3、用戶定義的構造函數

　　用戶定義的構造函數允許對象在被定義的時候同時被初始化。這種構造函數可以有任何類型的參數。一個用戶定義的和其它類型的構造函數在類 mystring 中得以體現：

class mystring   
{......  
public: mystring(); // Default constructor  
mystring (mystring &src)  
// Copy constructor  
mystring (char * scr);  
// Coercion constructor  
mystring ( char scr[ ], size_t len);  
// User-Defined constructor  
}; 

　　4、強制構造函數

　　C++中，可以聲明一個只有一個參數的構造函數來進行類型轉換。強制構造函數定一個從參數類型進行的一個類型轉換(隱式的或顯式的)。換句話說，編譯器可以用任何參數的實例來調用構造函數。這樣做的目的是建立一個臨時實例來替換一個參數類型的實例。注意標準新近加入C++的關鍵字explicit 是用來禁止隱式的類型轉換。然而，這一特性還沒能被所有的編譯器支持。下面是一個強制構造函數的例子：

class A   
{  
public :  
A(int ){ }  
};  
void f(A) { }   
void g()  
{  
A My_Object= 17;  
A a2 = A(57);  
A a3(64);  
My_Object = 67;  
f(77);  
};  

　　像A My_Object= 17;這種聲明意味著A(int)構造函數被調用來從整型變量生成一個對象。這樣的構造函數就是強制構造函數。

#p#

　　不合理普遍特性

　　下面是一些C++構造函數的不合理設計，當然，可能還有其他一些不合理之處。但是，大多數情況下，我們還是要和這些特性打交道，我們要逐一說明。

　　1、構造函數可以為內聯，但不要這樣做

　　一般來講，大多數成員函數都可以在前面加入"inline"關鍵字而成為內聯函數，構造函數也不例外，但是別這么做!一個被定義為內聯的構造函數如下：

class x   
{..........  
public : x (int );  
:  
:  
};  
inline x::x(int )  
{...}  

　　在上面的代碼中，函數并不是作為一個單獨的實體而是被插入到程序代碼中。這對于只有一兩條語句的函數來說會提到效率，因為這里沒有調用函數的開銷。

　　用內聯的構造函數的危險性可以在定義一個靜態內聯構造函數中體現。在這種情況下，靜態的構造函數應當是只被調用一次。然而，如果頭文件中含有靜態內聯構造函數，并被其他單元包括的話，函數就會產生多次拷貝。這樣，在程序啟動時就會調用所有的函數拷貝，而不是程序應當調用的一份拷貝。這其中的根本原因是靜態函數是在以函數偽裝下的真實對象。

　　應該牢記的一件事是內聯是建議而不是強制，編譯器產生內聯代碼。這意味著內聯是與實現有關的編譯器的不同可能帶來很多差異。另一方面，內聯函數中可能包括比代碼更多的東西。構造函數被聲明為內聯，所有包含對象的構造函數和基類的構造函數都需要被調用。這些調用是隱含在構造函數中的。這可能會創建很大的內聯函數段，所以，不推薦使用內聯的構造函數。

　　2、構造函數沒有任何返回類型

　　對一個構造函數指定一個返回類型是一個錯誤，因為這樣會引入構造函數的地址。這意味著將無法處理出錯。這樣，一個構造函數是否成功的創建一個對象將不可以通過返回之來確定。事實上，盡管C++的構造函數不可以返回，也有一個方法來確定是否內存分配成功地進行。這種方法是內建在語言內部來處理緊急情況的機制。一個預定好的函數指針 new-handler,它可以被設置為用戶定制的對付new操作符失敗的函數，這個函數可以進行任何的動作，包括設置錯誤標志、重新申請內存、退出程序或者拋出異常。你可以安心的使用系統內建的new-handler。最好的使構造函數發出出錯信號的方法，就是拋出異常。在構造函數中拋出異常將清除錯誤之前創建的任何對象及分配的內存。

　　如果構造函數失敗而使用異常處理的話，那么，在另一個函數中進行初始化可能是一個更好的主意。這樣，程序員就可以安全的構件對象并得到一個合理的指針。然后，初始化函數被調用。如果初始化失敗的話，對象直接被清除。

　　3、構造函數不可以被聲明為static

　　C++中，每一個類的對象都擁有類數據成員的一份拷貝。但是，靜態成員則沒有這樣而是所有的對象共享一個靜態成員。靜態函數是作用于類的操作，而不是作用在對象上。可以用類名和作用控制操作符來調用一個靜態函數。這其中的一個例外就是構造函數，因為它違反了面向對象的概念。

　　關于這些的一個相似的現象是靜態對象，靜態對象的初始化是在程序的一開始階段就進行的(在main()函數之前)。下面的代碼解釋了這種情況。

MyClass static_object(88, 91);  
 
void bar()  
{  
if (static_object.count( ) > 14) {  
...  
}  
} 

　　在這個例子中，靜態變量在一開始的時候就被初始化。通常這些對象由兩部分構成。第一部分是數據段，靜態變量被讀取到全局的數據段中。第二部分是靜態的初始化函數，在main()函數之前被調用。我們發現，一些編譯器沒有對初始化的可靠性進行檢查。所以你得到的是未經初始化的對象。解決的方案是，寫一個封裝函數，將所有的靜態對象的引用都置于這個函數的調用中，上面的例子應當這樣改寫。

static MyClass* static_object = 0;  
 
MyClass*  
getStaticObject()  
{  
if (!static_object)  
static_object =   
new MyClass(87, 92);  
return static_object;  
}  
 
void bar()  
{  
if (getStaticObject()->count( ) > 15)  
{  
...  
}  
} 

　　4、構造函數不能成為虛函數

　　虛構造函數意味著程序員在運行之前可以在不知道對象的準確類型的情況下創建對象。虛構造函數在C++中是不可能實現的。最通常遇到這種情況的地方是在對象上實現I/O的時候。即使足夠的類的內部信息在文件中給出，也必須找到一種方法實例化相應的類。然而，有經驗的C++程序員會有其他的辦法來模擬虛構造函數。

　　模擬虛函數需要在創建對象的時候指定調用的構造函數，標準的方法是調用虛的成員函數。很不幸，C++在語法上不支持虛構造函數。為了繞過這個限制，一些現成的方法可以在運行時刻確定構件的對象。這些等同于虛構造函數，但是這是C++中根本不存在的東西。

　　第一個方法是用switch或者if-else選擇語句來手動實現選擇。在下面的例子中，選擇是基于標準庫的type_info構造，通過打開運行時刻類型信息支持。但是你也可以通過虛函數來實現RTTI

class Base  
{  
public:  
virtual const char* get_type_id() const;  
staticBase* make_object  
(const char* type_name);  
};  
 
const char* Base::get_type_id() const 
{  
return typeid(*this).raw_name();  
}  
 
class Child1: public Base  
{  
};  
 
class Child2: public Base  
{  
};  
 
Base* Base::make_object(const char* type_name)  
{  
if (strcmp(type_name,  
typeid(Child1).raw_name()) == 0)  
　　return new Child1;  
else if (strcmp(type_name,typeid 
　　(Child2).raw_name()) == 0)  
return new Child2;  
else 
{  
　throw exception  
("unrecognized type name passed");  
return 0X00; // represent NULL  
　　}  
} 

　　這一實現是非常直接的，它需要程序員在main_object中保存一個所有類的表。這就破壞了基類的封裝性，因為基類必須知道自己的子類。

　　一個更面向對象的方法類解決虛構造函數叫做標本實例。它的基本思想是程序中生成一些全局的實例。這些實例只再虛構造函數的機制中存在：

class Base  
{  
public:  
　　staticBase* make_object(const char* typename)  
{  
　if (!exemplars.empty())  
　{  
　　Base* end = *(exemplars.end());  
　　list<Base*>::iterator iter =  
　　exemplars.begin();  
　　while (*iter != end)  
　　　{  
　　　　Base* e = *iter++;  
　　　　if (strcmp(typename,  
　　　　　　e->get_typename()) == 0)  
　　　　　　return e->clone();  
　　　}  
　}  
　　return 0X00 // Represent NULL;  
}  
virtual ~Base() { };  
virtual const char* get_typename() const 
{  
　return typeid(*this).raw_name();  
}  
virtual Base* clone() const = 0;  
protected:  
static list<Base*> exemplars;  
};  
list<Base*> Base::exemplars;  
// T must be a concrete class  
// derived from Base, above  
template<class T>  
class exemplar: public T  
{  
　public:  
　exemplar()  
　{  
　　exemplars.push_back(this);  
　}  
~exemplar()  
　{  
　exemplars.remove(this);  
　}  
};  
class Child: public Base  
{  
　public:  
　~Child()  
　　{  
　　}  
　Base* clone() const 
　{  
　　return new Child;  
　}  
};  
exemplar<Child> Child_exemplar;  

　　在這種設計中，程序員要創建一個類的時候要做的是創建一個相應的exampler類。注意到在這個例子中，標本是自己的標本類的實例。這提供了一種高校得實例化方法。

#p#

　　5、創建一個缺省構造函數

　　當繼承被使用的時候，卻省構造函數就會被調用。更明確地說，當繼承層次的最晚層的類被構造的時候，所有基類的構造函數都在派生基類之前被調用，舉個例子來說，看下面的代碼：

#include<iostream.h>  
class Base  
{  
　int x;  
　public :  
　　　　Base() : x(0) { } // The NULL constructor  
　　　　Base(int a) : x(a) { }  
};  
class alpha : virtual public Base  
　{  
　int y;  
　public :  
　alpha(int a) : Base(a), y(2) { }  
　};  
class beta : virtual public Base  
　{  
　int z;  
　public :  
　beta(int a) : Base(a), z(3) { }  
　};  
class gamma : public alpha, public beta  
　{  
　　int w;  
　　public :  
　　　　　gamma ( int a, int b) : alpha(a), beta(b), w(4) { }  
　};  
main()  
{.....  
}  

　　在這個例子中，我們沒有在gamma的頭文件中提供任何的初始化函數。編譯器會為基類使用缺省的構造函數。但是因為你提供了一個構造函數，編譯器就不會提供任何缺省構造函數。正如你看到的這段包含缺省構造函數的代碼一樣，如果刪除其中的缺省構造函數，編譯就無法通過。

　　如果基類的構造函數中引入一些副效應的話，比如說打開文件或者申請內存，這樣程序員就得確保中間基類沒有初始化虛基類。也就是，只有虛基類的構造函數可以被調用。

　　虛基類的卻省構造函數完成一些不需要任何依賴于派生類的參數的初始化。你加入一個init()函數，然后再從虛基類的其他函數中調用它，或在其他類中的構造函數里調用(你的確保它只調用了一次)。

　　6、不能取得構造函數的地址

　　C++中，不能把構造函數當作函數指針來進行傳遞，指向構造函數的的指針也不可以直接傳遞。允許這些就可以通過調用指針來創建對象。一種達到這種目的的方法是借助于一個創建并返回新對象的靜態函數。指向這樣的函數的指針用于新對象需要的地方。下面是一個例子：

class A  
{  
　public:  
　　A( ); // cannot take the address of this  
　　　　　// constructor directly  
　static A* createA();  
　　　// This function creates a new A object  
　　　// on the heap and returns a pointer to it.  
　　　// A pointer to this function can be passed  
　　　// in lieu of a pointer to the constructor.  
};  

　　這一方法設計簡單，只需要將抽象類置入頭文件即可。這給new留下了一個問題，因為準確的類型必須是可見的。上面的靜態函數可以用來包裝隱藏子類。

　　7、位拷貝在動態申請內存的類中不可行

　　C++中，如果沒有提供一個拷貝構造函數，編譯器會自動生成一個。生成的這個拷貝構造函數對對象的實例進行位拷貝。這對沒有指針成員的類來說沒什么，但是，對用了動態申請的類就不是這樣的了。為了澄清這一點，設想一個對象以值傳遞的方式傳入一個函數，或者從函數中返回，對象是以為拷貝的方式復制。這種位拷貝對含有指向其他對象指針的類是沒有作用的。當一個含有指針的類以值傳遞的方式傳入函數的時候，對象被復制，包括指針的地址，還有，新的對象的作用域是這個函數。在函數結束的時候，很不幸，析構函數要破壞這個對象。因此，對象的指針被刪除了。這導致原來的對象的指針指向一塊空的內存區域-一個錯誤。在函數返回的時候，也有類似的情況發生。

　　這個問題可以簡單的通過在類中定義一個含有內存申請的拷貝構造函數來解決，這種靠叫做深拷貝，是在堆中分配內存給各個對象的。

　　8、編譯器可以隱式指定強制構造函數

　　因為編譯器可以隱式選擇強制構造函數，你就失去了調用函數的選擇權。如果需要控制的話，不要聲明只有一個參數的構造函數，取而代之，定義helper函數來負責轉換，如下面的例子：

#include <stdio.h>  
#include <stdlib.h>  
class Money  
{  
　public:  
　　　　Money();  
　　　　// Define conversion functions that can only be  
　　　　// called explicitly.  
　　　　static Money Convert( char * ch )  
　　　　{ return Money( ch ); }  
　　　　static Money Convert( double d )  
　　　　{ return Money( d ); }  
　　　　void Print() { printf( "%f", _amount ); }  
　private:  
　　　　Money( char *ch ) { _amount = atof( ch ); }  
　　　　Money( double d ) { _amount = d; }  
　　　　double _amount;  
　　　};  
 
void main()  
{  
　// Perform a conversion from type char *  
　// to type Money.  
　Money Account = Money::Convert( "57.29" );  
　Account.Print();  
　// Perform a conversion from type double to type  
　// Money.  
　Account = Money::Convert( 33.29 );  
　Account.Print();  
} 

　　在上面的代碼中，強制構造函數定義為private而不可以被用來做類型轉換。然而，它可以被顯式的調用。因為轉換函數是靜態的，他們可以不用引用任何一個對象來完成調用。

　　總結

　　要澄清一點是，這里提到的都是我們所熟知的ANSI C++能夠接受的。許多編譯器都對ANSI C++進行了自己的語法修訂。這些可能根據編譯器的不同而不同。很明顯，許多編譯器不能很好的處理這幾點。探索這幾點的緣故是引起編譯構造的注意，也是在C++標準化的過程中移除一些瑕疵。

【編輯推薦】

1. 程序員必看 c++筆試題匯總
2. C++構造函數如何進行初始化
3. 淺析C++中的C++構造函數
4. C#構造函數概述
5. 深度探討C++靜態構造函數