2. 程式人生 > >C++繼承與建構函式、複製控制

C++繼承與建構函式、複製控制

阿新 • • 發佈：2018-12-25

        每個派生類物件由派生類中定義的（非static）成員加上一個或多個基類子物件構成，因此，當構造、複製、賦值和撤銷派生型別物件時，也會構造、複製、賦值和撤銷這些基類子物件。

建構函式和複製控制成員不能繼承，每個類定義自己的建構函式和複製控制成員。像任何類一樣，如果類不定義自己的預設建構函式和複製控制成員，就將使用合成版本。

1：建構函式和繼承

       派生類的建構函式受繼承關係的影響，每個派生類建構函式除了初始化自己的資料成員之外，還要初始化基類。

派生類的合成預設建構函式：除了初始化派生類的資料成員之外，它還初始化派生類物件的基類部分。基類部分由基類的預設建構函式初始化：

class father
{
public:
    int publ_i;
    father(int a=1, int b=2, int c=3):publ_i(a),priv_i(b), prot_i(c) 
    {
        cout << "father constructor" << endl;
    }
    virtual void display()
    {
        cout << "[father]publ_i is " << publ_i << endl;
        cout << "[father]priv_i is " << priv_i << endl;
        cout << "[father]prot_i is " << prot_i << endl;
    }
private:
    int priv_i;
protected:
    int prot_i;
};

class son: public father
{
public:
    void display()
    {
        cout << "[son]publ_i is " << publ_i << endl;
        cout << "[son]prot_i is " << prot_i << endl;
    }
};
int main()
{
    son ss1;
    ss1.display();
}

執行”son ss1;”語句時，呼叫派生類son的合成的預設建構函式，該函式會首先呼叫基類的預設建構函式。上述程式碼的結果是：

father constructor
[son]publ_i is 1
[son]prot_i is 3

如果派生類自己定義了建構函式，則該建構函式會隱式呼叫基類的預設建構函式：

class son: public father
{
public:
    son(int a = 2):mypriv_i(a)
    {
        cout << "son constructor" << endl;
    }
    void display()
    {
        cout << "[son]publ_i is " << publ_i << endl;
        cout << "[son]prot_i is " << prot_i << endl;
        cout << "[son]mypriv_i is " << mypriv_i << endl;
    }
private:
    int mypriv_i;
};

int main()
{
    son ss1;
    ss1.display();
}

執行”son ss1;”語句時，呼叫派生類son的預設建構函式，該函式首先呼叫基類的預設建構函式初始化基類部分，然後，使用初始化列表初始化son::mypriv_i，最後，在執行son建構函式的函式體。上述程式碼的結果是：

father constructor
son constructor
[son]publ_i is 1
[son]prot_i is 3
[son]mypriv_i is 2

派生類建構函式還可以明確的在初始化列表中呼叫基類的建構函式，來間接的初始化基類成員。注意，在派生類列表中，不能直接初始化基類成員：

class son: public father
{
public:
    son(int a = 2):mypriv_i(a),father(100)
    {
        cout << "son constructor" << endl;
    }
    void display()
    {
        cout << "[son]publ_i is " << publ_i << endl;
        cout << "[son]prot_i is " << prot_i << endl;
        cout << "[son]mypriv_i is " << mypriv_i << endl;
    }
private:
    int mypriv_i;
};
int main()
{
    son ss1;
    ss1.display();
}

不管初始化列表中的順序如何，派生類建構函式，都是首先呼叫基類建構函式初始化基類成員，然後是根據派生類成員的宣告順序進行初始化。

         如果嘗試在初始化列表中直接初始化基類成員，會發生編譯錯誤：

    son(int a = 2):mypriv_i(a),publ_i(100)
    {
        cout << "son constructor" << endl;
    }

        報錯如下：

test2.cpp: In constructor ‘son::son(int)’:
test2.cpp:29:29: error: class ‘son’ does not have any field named ‘publ_i’
  son(int a = 2):mypriv_i(a),publ_i(100)
                             ^

派生類建構函式不能初始化基類的成員且不應該對基類成員賦值。如果那些成員為 public 或 protected，派生建構函式可以在建構函式函式體中給基類成員賦值，但是，這樣做會違反基類的介面。派生類應通過使用基類建構函式尊重基類的初始化意圖，而不是在派生類建構函式函式體中對這些成員賦值。

注意，一個類只能初始化自己的直接基類。

2：複製控制和繼承

派生類合成的複製控制函式，對物件的基類部分連同派生部分的成員一起進行復制、賦值或撤銷，自動呼叫基類的複製建構函式、賦值操作符或解構函式對基類部分進行復制、賦值或撤銷：

class father
{
public:
    int publ_i;
    father(int a=1, int b=2, int c=3):publ_i(a),priv_i(b), prot_i(c) 
    {
        cout << "father constructor" << endl;
    }
    father(const father &src):publ_i(src.publ_i), priv_i(src.priv_i), prot_i(src.prot_i)
    {
        cout << "father copy constructor" << endl;
    }
    
    father& operator=(const father& src)
    {
        publ_i = src.publ_i;
        priv_i = src.priv_i;
        prot_i = src.prot_i;
        
        cout << "father operator = " << endl;
        return *this;
    }
    ~father()
    {
        cout << "father destructor" << endl;
    }
    virtual void display()
    {
        cout << "[father]publ_i is " << publ_i << endl;
        cout << "[father]priv_i is " << priv_i << endl;
        cout << "[father]prot_i is " << prot_i << endl;
    }
private:
    int priv_i;
protected:
    int prot_i;
};

class son: public father
{
public:
    son(int a = 2):mypriv_i(a)
    {
        cout << "son constructor" << endl;
    }
    void display()
    {
        cout << "[son]publ_i is " << publ_i << endl;
        cout << "[son]prot_i is " << prot_i << endl;
        cout << "[son]mypriv_i is " << mypriv_i << endl;
    }
private:
    int mypriv_i;
};
int main()
{
    son ss1(3);
    son ss2(ss1);
    ss2.display();
    
    son ss3;
    ss3 = ss1;
    ss3.display();
}

“son ss2(ss1);”語句，將呼叫派生類son的合成的複製建構函式，該建構函式將會自動呼叫基類的複製建構函式；”ss3 = ss1;”語句，將呼叫派生類son的合成的賦值操作符函式，該函式會自動呼叫基類的賦值操作符函式；最後，程式退出之前，會將派生類son的三個物件進行析構，從而自動呼叫基類的解構函式；上述程式碼的結果如下：

father constructor
son constructor
father copy constructor
[son]publ_i is 1
[son]prot_i is 3
[son]mypriv_i is 3
father constructor
son constructor
father operator = 
[son]publ_i is 1
[son]prot_i is 3
[son]mypriv_i is 3
father destructor
father destructor
father destructor

如果派生類自己定義了複製建構函式或賦值操作符，則應該顯示的呼叫基類的複製建構函式或賦值操作符：

class father
{
public:
    int publ_i;
    father(int a=1, int b=2, int c=3):publ_i(a),priv_i(b), prot_i(c) 
    {
        cout << "father constructor" << endl;
    }
    father(const father &src):publ_i(src.publ_i), priv_i(src.priv_i), prot_i(src.prot_i)
    {
        cout << "father copy constructor" << endl;
    }
    
    father& operator=(const father& src)
    {
        publ_i = src.publ_i;
        priv_i = src.priv_i;
        prot_i = src.prot_i;
        
        cout << "father operator = " << endl;
        return *this;
    }
    ~father()
    {
        cout << "father destructor" << endl;
    }
    virtual void display()
    {
        cout << "[father]publ_i is " << publ_i << endl;
        cout << "[father]priv_i is " << priv_i << endl;
        cout << "[father]prot_i is " << prot_i << endl;
    }
private:
    int priv_i;
protected:
    int prot_i;
};

class son: public father
{
public:
    son(int a = 2):mypriv_i(a),father(100)
    {
        cout << "son constructor" << endl;
    }
    son(const son& src):mypriv_i(src.mypriv_i),father(src)
    {
        cout << "son copy constructor" << endl;
    }
    son& operator=(const son& src)
    {
        father::operator=(src);
        mypriv_i = src.mypriv_i;
        
        cout << "son operator = " << endl;
        return *this;
    }
    void display()
    {
        cout << "[son]publ_i is " << publ_i << endl;
        cout << "[son]prot_i is " << prot_i << endl;
        cout << "[son]mypriv_i is " << mypriv_i << endl;
    }
private:
    int mypriv_i;
};
int main()
{
    son ss1(3);
    son ss2(ss1);
    ss2.display();
    
    son ss3;
    ss3 = ss1;
    ss3.display();
}

在派生類son的複製建構函式中，初始化列表中顯示呼叫基類複製建構函式使用src初始化基類部分。這裡如果省略呼叫基類複製建構函式的呼叫的話，編譯器會自動呼叫基類的預設建構函式初始化基類部分，這就造成新構造的物件會有比較奇怪的配置，它的基類部分儲存預設值，而他的派生類部分是src的副本；

在派生類son的賦值操作符函式中，顯示呼叫了基類的賦值操作符函式。如果省略了這一呼叫，則賦值操作，僅僅使該物件的mypriv_i與src的mypriv_i相同；

上述程式碼的結果如下：

father constructor
son constructor
father copy constructor
son copy constructor
[son]publ_i is 100
[son]prot_i is 3
[son]mypriv_i is 3
father constructor
son constructor
father operator = 
son operator = 
[son]publ_i is 100
[son]prot_i is 3
[son]mypriv_i is 3
father destructor
father destructor
father destructor

如果定義了派生類的解構函式，則不同於複製建構函式和賦值操作符：編譯器會自動呼叫基類的解構函式，因此在派生類的解構函式中，只負責清除自己的成員：

    ~son()
    {
        cout << "son destructor" << endl;
    }

定義了son的解構函式之後，上述程式碼的結果是：

...
son destructor
father destructor
son destructor
father destructor
son destructor
father destructor

物件的撤銷順序與構造順序相反：首先執行派生解構函式，然後按繼承層次依次向上呼叫各基類解構函式。

另外，如果基類指標指向了一個派生類物件，則刪除該基類指標時，如果基類的解構函式不是虛擬函式的話，則只會呼叫基類的解構函式，而不會呼叫派生類解構函式。比如還是上面的father和son兩個類，執行下面的程式碼：

    father *fp = new son;
    delete fp;

結果就是：

father constructor
son constructor
father destructor

為了避免這種情況的發生，應該將基類的解構函式定義為虛擬函式，這樣，無論派生類顯式定義解構函式還是使用合成解構函式，派生類解構函式都是虛擬函式。從而可以得到正確的結果。

因此，即使解構函式沒有工作要做，繼承層次的根類也應該定義一個虛解構函式。

3：建構函式或解構函式中呼叫虛擬函式

在執行建構函式或解構函式的時候，物件都是不完整的。為了適應這種不完整，編譯器將物件的型別視為在構造或析構期間發生了變化。在基類建構函式或解構函式中，將派生類物件當作基類型別物件對待。

因此，如果是在建構函式或解構函式中呼叫虛擬函式，則執行的是為建構函式或解構函式自身型別定義的版本。如果在基類建構函式中呼叫虛擬函式，則構造派生類的時候，該虛擬函式實際上還是呼叫的基類的版本：

class father
{
public:
    int publ_i;
    father(int a=1, int b=2, int c=3):publ_i(a),priv_i(b), prot_i(c) 
    {
        cout << "father constructor" << endl;
        display();
    }
    virtual void display()
    {
        cout << "[father]publ_i is " << publ_i << endl;
        cout << "[father]priv_i is " << priv_i << endl;
        cout << "[father]prot_i is " << prot_i << endl;
    }

private:
    int priv_i;
protected:
    int prot_i;
};

class son: public father
{
public:
    son()
    {
        cout << "son constructor" << endl;
    }
    
    void display()
    {
        cout << "[son]publ_i is " << publ_i << endl;
        cout << "[son]prot_i is " << prot_i << endl;
    }
};

int main()
{
    father *fp = new son;
}

在構造son物件時，需要呼叫father的建構函式，在father的建構函式中呼叫了虛擬函式display。此時，雖然構造的是派生類物件，但是這裡依然還是呼叫基類的display函式。因此，上述程式碼的結果為：

father constructor
[father]publ_i is 1
[father]priv_i is 2
[father]prot_i is 3
son constructor

無論由建構函式（或解構函式）直接呼叫虛擬函式，或者從建構函式（或解構函式）所呼叫的函式間接呼叫虛擬函式，都應用這種繫結。

要理解這種行為，考慮如果從基類建構函式（或解構函式）呼叫虛擬函式的派生類版本會怎麼樣。虛擬函式的派生類版本很可能會訪問派生類物件的成員，但是，物件的派生部分的成員不會在基類建構函式執行期間初始化，實際上，如果允許這樣的訪問，程式很可能會崩潰。

相關推薦

C++繼承與建構函式、複製控制

        每個派生類物件由派生類中定義的（非static）成員加上一個或多個基類子物件構成，因此，當構造、複製、賦值和撤銷派生型別物件時，也會構造、複製、賦值和撤銷這些基類子物件。 建構函式和複製控制成員不能繼承，每個類定義自己的建構函式和複製控制成員。像任何類一樣，

C++在單繼承、多繼承、虛繼承時，建構函式、複製建構函式、賦值操作符、解構函式的執行順序和執行內容

一、本文目的與說明     1. 本文目的：理清在各種繼承時，建構函式、複製建構函式、賦值操作符、解構函式的執行順序和執行內容。     2. 說明：雖然複製建構函式屬於建構函式的一種，有共同的地方，但是也具有一定的特殊性，所以在總結它的性質時將它單獨列出來了。  

C++中拷貝建構函式、淺拷貝與深拷貝的詳解

拷貝建構函式呼叫時機： 1、物件需要通過另外一個物件進行初始 化：     T t1(10, 20);T t2(0, 0);T t3 = t1; // 拷貝建構函式呼叫的時機一：T t4(t2);  // 拷貝建構函式呼叫的時機 二：2、實參傳遞給形參時呼叫賦值建構函式 拷

C++派生類的建構函式和複製控制

派生類的建構函式和複製控制成員不能繼承，每個類定義自己的建構函式和複製控制成員，像任何類一樣，如果類沒有定義自己的建構函式和複製控制成員，編譯器自動合成。 1.建構函式 派生類的建構函式先要初始化基類

建構函式、複製建構函式、賦值運算子的呼叫

1：呼叫無參建構函式，故：Foo constructor。 2：向函式f傳入剛才構造的物件vf1，函式結束值vf1要銷燬。故：Foo copy constructor，Foo destructor 3：由於g函式的形參是引用，故不會呼叫建構函式 4：由於定義物件，並對此物件用產生的物件進行復制（建立一個

繼承與建構函式

問題描述:設計一個學生類Student，其屬性有：姓名(name)、年齡(age)、學歷(education),由Student類派生出本科生類Undergraduate和研究生類Graduate，本科生類增加屬性：專業(specialty),研究生類增加屬性：研究方向(direction)。每

C++的拷貝建構函式、operator=運算子過載，深拷貝和淺拷貝、explicit關鍵字

1、在C++編碼過程中，類的建立十分頻繁。 簡單的功能，當然不用考慮太多，但是從進一步深刻理解C++的內涵，類的結構和用法，編寫更好的程式碼的角度去考慮，我們就需要用到標題所提到的這些內容。 最近，在看單例模式，覺得十分有趣，然而如果想要掌握單例模式，就必須掌握這些內容。下

標準C時間與日期函式、記憶體函式

標準C時間與日期函式 asctime() 時間文字格式 clock() 返回自程式開始執行所經過的時間 ctime() 返回特定格式時間

C++繼承中建構函式和解構函式的呼叫順序

class Fish:public Animal { public: Fish() { cout<<"this is Fish"<<endl; } ~Fish() { cout<<"this is free Fish"<<en

C++之拷貝建構函式和複製運算子過載

1、C++拷貝建構函式 拷貝建構函式是為了解決如神明物件時候就用一個已經存在的物件來初始化這個新的物件，如MyString A(B)：這裡B是已經存在MyString物件。但是這裡需要注意拷貝建構函式裡面的內部實現細節。這裡面其實是在這個A物件類的定義中定義了拷貝建構函式的

繼承與建構函式分析

--- class Person { private String name; private String location; Person(String name) { this.name = name; location = "beijing"; }

C++11新特性(80)-繼承的建構函式與多重繼承

複習 本文算是前面文章的繼續。 對於繼承的建構函式，C++11通過一個簡單的using語句，使得繼承一個類時可以省去一些麻煩。具體可以參照下面的文章。 C++11新特性（59）-繼承的建構函式 https://mp.weixin.qq.com/s/BGUa7-RSCtFRnBYj

# c++中的複合與繼承相關建構函式的呼叫先後

複合關係 #include <iostream> class A{ public: A(int m=0):a(m){ std::cout<<"base's defualt建構函式"<<std::

C++類中的一些細節(過載、重寫、覆蓋、隱藏，建構函式、解構函式、拷貝建構函式、賦值函式在繼承時的一些問題)

1 函式的過載、重寫（重定義）、函式覆蓋及隱藏 其實函式過載與函式重寫、函式覆蓋和函式隱藏不是一個層面上的概念。前者是同一個類內，或者同一個函式作用域內，同名不同引數列表的函式之間的關係。而後三者是基類和派生類函式不同情況下的關係。 1.1 函式過載

c++拷貝建構函式、賦值運算子=過載、深拷貝與淺拷貝

 關鍵詞：建構函式，淺拷貝，深拷貝，堆疊(stack)，堆heap，賦值運算子 摘要:     在面向物件程式設計中，物件間的相互拷貝和賦值是經常進行的操作。     如果物件在宣告的同時馬上進行的初始化操作，則稱之為拷貝運算。例如：         class1 A(

《隨筆一》——C#中的“靜態建構函式、物件初始化語句”

  靜態建構函式 ● 我們在使用類中的靜態成員時，先要初始化這些成員。 在宣告靜態成員時、可以同時提供一個初始值。 但有時候我們需要執行更復雜的初始化操作， 這應該怎麼辦呢？ ● 我們可以把建構函式宣告成static的， 一般來說， 靜態的建構函式初始化類的靜態欄位

【C++初學】類和物件定義與建構函式

一.類和物件定義 class 型別名 { public: 公有成員（外部介面） private： 私有成員（只允許類內函式訪問，有後續操作） protected： 保護成員 二.建構函式 def：給物件進行初始化的函式。 gra： 函式名與類名相同； 無返回值（return）； 1.委託

Vue 建構函式、生命週期與資料雙向繫結

Vue2 建構函式、生命週期與資料雙向繫結 Vue是一個響應式的、漸進式的JavaScript框架，它在設計上採用MVVM模式，將檢視與資料兩部分分離。下面就是一個簡單的Vue例項： <!DOCTYPE html> <html lang="en"> <h

C#類繼承中建構函式的執行序列

不知道大家在使用繼承的過程中有木有遇到過呼叫建構函式時沒有按照我們預期的那樣執行呢？一般情況下，出現這樣的問題往往是因為類繼承結構中的某個基類沒有被正確例項化，或者沒有正確給基類建構函式提供資訊，如果理解在物件生命週期的這個階段發生的事情，將更利於解決此類問題。 為了例項化派生的類，必須先例項化它的基類。而

類和物件——建構函式、解構函式、複製建構函式

類： 要宣告類，用class，注意區分大小寫。類含有成員屬性和方法。在宣告類的末尾要加分號； 物件： 宣告完類之後，它並不能對程式產生任何影響。只有依據類，例項化物件，才可以訪問類成員屬性和方法。 下面是類例項化物件、動態分配記憶體與變數的對比： double pi=3.14; int* p