構造函數與析構函數詳解

本文demo下載地址：http://www.wisdomdd.cn/Wisdom/resource/articleDetail.htm?resourceId=1134

構造函數

構造函數的特色：以類名做爲函數名，無返回類型。

若是建立一個類程序員沒有寫任何構造函數,則系統會自動生成默認的無參構造函數，函數爲空，什麼都不作。構造函數就是構造一個類對象會運行的函數。

eg：

Counter(){}

只要程序員寫了某種構造函數，系統就不會再自動生成這樣一個默認的構造函數。

構造函數是一類特殊的函數，與其餘的成員函數不一樣的是構造函數構造函數不須要用戶來調用它，而是創建對象的時候自動的執行。

該類對象被建立時，編譯系統對象分配內存空間，並自動調用該構造函數->由構造函數完成成員的初始化工做。

構造函數的做用：初始化對象的數據成員

構造函數種類：

1． 通常構造函數（也稱重載構造函數）通常構造函數能夠有各類參數形式,一個類能夠有多個通常構造函數，前提是參數的個數或者類型不一樣（基於c++的重載函數原理）建立對象時根據傳入的參數不一樣調用不一樣的構造函數。

Eg: Complex(void)

m_real = 0.0;

m_imag = 0.0;

Complex(double real, double imag)

m_real = real;

m_imag = imag;

2． 複製構造函數（也稱爲拷貝構造函數）

複製構造函數參數爲類對象自己的引用，用於根據一個已存在的對象複製出一個新的該類的對象，通常在函數中會將已存在對象的數據成員的值複製一份到新建立的對象中。

若沒有顯示的寫複製構造函數，則系統會默認建立一個複製構造函數，但當類中有指針成員時，由系統默認建立該複製構造函數會存在風險，具體緣由請查詢 有關 「淺拷貝」 、「深拷貝」的文章論述。

Eg: Complex(const Complex & c)

// 將對象 c中的數據成員值複製過來

m_real = c.m_real;

m_imag = c.m_imag;

//當用一個對象a去初始化另一個對象b時，會觸發複製構造函數，當b被第二次被賦值時，不會執行構造函數。b的生命週期被銷燬時，會去執行析構函數，銷燬b當中最新的數據。

3． 等號運算符重載（也叫賦值構造函數）

它不屬於構造函數，等號左右兩邊的對象必須已經被建立

注意，這個相似複製構造函數，將=右邊的本類對象的值複製給等號左邊的對象，

若沒有顯示的寫=運算符重載，則系統也會建立一個默認的=運算符重載，只作一些基本的拷貝工做。

Eg: Complex &operator=( const Complex &rhs )

// 首先檢測等號右邊的是否就是左邊的對象自己，如果本對象自己,則直接返回

if ( this == &rhs )

return *this;

// 複製等號右邊的成員到左邊的對象中

this->m_real = rhs.m_real;

this->m_imag = rhs.m_imag;

// 把等號左邊的對象再次傳出

// 目的是爲了支持連等 eg: a=b=c 系統首先運行 b=c

// 而後運行 a= ( b=c的返回值,這裏應該是複製c值後的b對象)

return *this;

實例：

Eg:

int main()

// 自動調用了無參構造函數，數據成員初值被賦爲0.0

Complex c1，c2;// 若是定義一個對象時沒有提供初始化式，就使用默認構造函數。

//自動調用有兩個函數的構造函數，數據成員初值被賦爲指定值

Complex c3(1.0,2.5);

// 也可使用下面的形式

Complex c3 = Complex(1.0,2.5);

// 把c3的數據成員的值賦值給c1

// 因爲c1已經事先被建立，故此處不會調用任何構造函數

// 只會調用 = 號運算符重載函數，應爲c1和c3已被定義。

c1 = c3;

// 調用類型轉換構造函數

// 系統首先調用類型轉換構造函數，將5.2建立爲一個本類的臨時對象，而後調用等號運算符重載，將該臨時對象賦值給c1

c2 = 5.2;

// 調用拷貝構造函數( 有下面兩種調用方式) //此時只執行顯示定義複製構造函數。

Complex c5(c2);

Complex c4 = c2; // 注意和 = 運算符重載區分,這裏等號左邊的對象不是事先已經建立，故須要調用拷貝構造函數，參數爲c2

//這一點特別重要，這兒是初始化，不是賦值。其實這兒就涉及了C++中的兩種初始化的方式：複製初始化和賦值初始化。其中c5採用的是複製初始化，而c4採用的是賦值初始化，這兩種方式都是要調用拷貝構造函數的。

二．析構函數

在設計一個類的時候，若是咱們一個構造函數都沒有寫，那麼 C++ 會幫咱們寫一個構造函數。只要咱們寫了一個構造函數，那麼 C++ 就不會再幫咱們寫構造函數了。

析構函數特色：析構函數是這樣寫的： 函數名前面都加了一個 ~ 符號。 析構函數都是沒有參數，也就是說：析構函數永遠只能寫一個。

析構函數做用：析構函數是用來撤銷對象，釋放資源，它與構造函數對應。釋放了以後，這些資源就會被回收，能夠被從新利用。析構函數, 在類的聲明週期結束的時候運行的函數。

好比說，咱們在構造函數裏打開文件，在析構函數裏關閉打開的文件。這是一個比較好的作法。

在構造函數裏，咱們去鏈接數據庫的鏈接，在析構函數裏關閉數據庫的鏈接。

在構造函數裏動態的分配內存，那麼在析構函數裏把動態分配的內存回收。

若是咱們寫的類是一個沒有那麼複雜的類，咱們能夠不須要寫析構函數。若是一個類只要有這些狀況：打開文件、動態分配內存、鏈接數據庫。簡單的說：就是隻要構造函數裏面有了 new這個關鍵詞，咱們就須要本身手動編寫析構函數。

那麼若是咱們寫了析構函數，就必需要注意三法則：同時編寫：析構函數、賦值構造函數、賦值運算符。

#include <iostream>

#include <string>

using namespace std;

class NoName{

public:

NoName():pstring(new std::string)

, i(0), d(0){

cout << "構造函數被調用了！" << endl;

NoName(const NoName & other);

~NoName();

NoName& operator =(const NoName &rhs);

private:

std::string * pstring;

int i;

double d;

};

NoName::~NoName(){

cout << "析構函數被調用了！" << endl;

NoName::NoName(const NoName & other){

pstring = new std::string;//

*pstring = *(other.pstring);//將內容進複製

i = other.i;

d = other.d;

NoName& NoName::operator=(const NoName &rhs){

pstring = new std::string;

*pstring = *(rhs.pstring);

i = rhs.i;

d = rhs.d;

return *this;

int main(){

NoName a;

NoName *p = new NoName;

delete p;

return 0;

注：建立一個對象的數組時，分別爲每個調用了構造函數，刪除一個動態數組對象的時候系統幫你自動爲每個調用了析構函數。

#include <string>

#include <iostream>

using namespace std;

class Fruit //定義一個類，名字叫Fruit

string name; //定義一個name成員

string colour; //定義一個colour成員

public:

void print() //定義一個輸出名字的成員print()

cout<<colour<<" "<<name<<endl;

Fruit(const string &nst = "apple",const string &cst = "green"):name(nst),colour(cst)

cout <<"Aha,I'm "<<name<<". I have created!"<<endl;

} //構造函數

Fruit(Fruit &aF) //還記得我嗎?我是複製構造函數

name = "another " +aF.name;

~Fruit()

cout <<"Dame it!"<<"I'm "<<name<<". And who killed me?"<<endl;

};

int main()

cout<<"main begin"<<endl;

cout<<"created *P"<<endl;

Fruit *p = new Fruit[10];

cout<<"created another apple"<<endl;

Fruit apple(*p);

cout<<"delete p"<<endl;

delete []p;//new []和delete []對應，new 和delete 對應，

cout<<"main end"<<endl;

return 0;