第二章繼承與派生-創(chuàng)新互聯(lián)

這節(jié)課,我們來學(xué)習(xí)繼承。

站在用戶的角度思考問題,與客戶深入溝通,找到青河網(wǎng)站設(shè)計與青河網(wǎng)站推廣的解決方案,憑借多年的經(jīng)驗,讓設(shè)計與互聯(lián)網(wǎng)技術(shù)結(jié)合,創(chuàng)造個性化、用戶體驗好的作品,建站類型包括:做網(wǎng)站、網(wǎng)站建設(shè)、企業(yè)官網(wǎng)、英文網(wǎng)站、手機端網(wǎng)站、網(wǎng)站推廣、申請域名、網(wǎng)絡(luò)空間、企業(yè)郵箱。業(yè)務(wù)覆蓋青河地區(qū)。

當(dāng)從基類派生出新類時,可以對派生類作如下幾個變化:

1、可以增加新的成員函數(shù)。

2、可以增加新的成員變量。

3、可以重新定義已有的成員函數(shù)。

4、可以改變現(xiàn)有的成員屬性。

我們先來學(xué)習(xí)一個簡單的派生例子

//這是一個簡單的派生例子

首先,創(chuàng)建一個Location類

Location.h文件如下:

#include <iostream>
using namespace std;
class Location
{
private:
    int iPointX;
                                                                                                                                                                                                                                                                                                                   
public:
    void setPointX(int _iPointX)
    {
        iPointX = _iPointX;
    }
    void showX()
    {
        cout<<"X="<<iPointX<<endl;
    }
                                                                                                                                                                                                                                                                                                                   
                                                                                                                                                                                                                                                                                                                   
};

再創(chuàng)建一個Rectangle類

Rectangle.h文件如下:

#include <iostream>
#include "Location.h"
//此處可以不寫因為可以繼承
//using namespace std;
class Rectangle:public Location
{
private:
    int iHight;
                                                                                                                                                                                                                                                                                          
public:
    void setHight(int _iHight)
    {
        iHight = _iHight;
    }
    void showH()
    {
        cout<<"H = "<<iHight<<endl;
                                                                                                                                                                                                                                                                                              
    }
                                                                                                                                                                                                                                                                                          
};

main函數(shù)如下:

#include "Rectangle.h"
int main(int argc, const char * argv[])
{
    Rectangle rect;
    rect.setPointX(10);
    rect.setHight(20);
                                                                                                                                                                                                                                                                                      
    rect.showX();
     rect.showH();
                                                                                                                                                                                                                                                                                       
    return 0;
}

代碼下載:http://pan.baidu.com/share/link?shareid=2883935448&uk=3189484501

訪問規(guī)則

私有派生例子:

#include <iostream>

usingnamespacestd;

//程序分析:

//在這個例子中,基類的公有成員iVarA通過私有派生成了派生類的私有成員,所以當(dāng)Derived類再派生其子類時,iVarA是不可訪問的。

//由于私有派生這個特點,因此在實際工作中私有派生很少使用。

class Base
{
public:
int iVarA;
    Base()
    {
iVarA = 10;
    }
};
class Derived:private Base
{
public:
int iVarC;
    Derived()
    {
iVarC = 30;
    }
void show()
    {
cout<<iVarA<<" "<<iVarC<<endl;
    }
};
int main(int argc, constchar * argv[])
{
Derived derObj;
    derObj.show();
return0;
}

代碼下載: http://pan.baidu.com/share/link?shareid=3533495783&uk=3189484501

保護派生

#include <iostream>
using namespace std;
//程序分析:
//在保護派生中,基類的私有和不可訪問成員在派生類中是不可訪問的成員在派生類中是不可訪問的,基類的保護成員繼續(xù)是保護的,而基類的公有成員在派生類中則變?yōu)楸Wo的。
class Base
{
                                                                                                                                                                                                       
                                                                                                                                                                                                       
public:
    int iVarA;
    Base()
    {
        iVarA = 10;
    }
};
class Derived:protected Base
{
                                                                                                                                                                                                       
public:
    int iVarC;
    Derived()
    {
        iVarC = 30;
    }
    void show()
    {
        cout<<iVarA<<" "<<iVarC<<endl;
    }
};
class Temp
{
                                                                                                                                                                                                       
public:
    void tempShow()
    {
        Derived tempD;
        //下面這行代碼報錯  雖然它在Derived的父類即Base類是公有的,但Derived類通過protected繼承 因此其繼承來的也會變?yōu)閜rotected  所以其他類不能直接訪問
      //  tempD.iVarA = 10;
    }
};
int main(int argc, const char * argv[])
{
    Derived derObj;
    derObj.show();
    return 0;
}

下載地址:http://pan.baidu.com/share/link?shareid=792966415&uk=3189484501

多重繼承例子

#include <iostream>
//類C是從類A和類B中共同派生出來的。類C從類A公有派生,因此,類A的中公有函數(shù)setA和showA在類C中都是公有。
//類C從類B中私有派生,所以類B中的公有函數(shù),在類C中就是私有的。
using namespace std;
class A
{
private:
    int iVarA;
                                                                                                                                                                                          
                                                                                                                                                                                          
public:
    void setA(int _iVarA)
    {
        iVarA = _iVarA;
    }
    void showA()
    {
        cout<<"iVarA:"<<iVarA<<endl;
    }
                                                                                                                                                                                          
};
class B
{
                                                                                                                                                                                          
                                                                                                                                                                                          
public:
    int iVarB;
    void setB(int _iVarB)
    {
        iVarB = _iVarB;
    }
    void show()
    {
        cout<<iVarB<<endl;
    }
                                                                                                                                                                                          
};
class C:public A ,private B
{
private:
    int iVarC;
                                                                                                                                                                                          
                                                                                                                                                                                          
public:
    void setC(int _iVarA,int _iVarB,int _iVarC)
    {
        setA(_iVarA);
        setB(_iVarB);
        iVarC = _iVarC;
    }
    void showC()
    {
        cout<<"iVarC:"<<iVarC<<endl;
    }
                                                                                                                                                                                          
};
int main(int argc, const char * argv[])
{
    C cObj;
    cObj.setC(1, 2, 3);
    cObj.showA();
    cObj.showC();
                                                                                                                                                                                         
                                                                                                                                                                                          
    return 0;
}

多重繼承中構(gòu)造函數(shù)和析構(gòu)函數(shù)的調(diào)用順序

#include <iostream>
using namespace std;
class A
{
protected:
    int iVarA;
                                                                                                                                                                     
public:
    A(int _iVarA)
    {
        iVarA = _iVarA;
        cout<<"Construction A,iVarA = "<<iVarA<<endl;
                                                                                                                                                                         
    }
    ~A()
    {
        cout<<"Destorying A,iVarA="<<iVarA<<endl;
    }
                                                                                                                                                                     
};
class B:public A
{
private:
    A objA;
    int iVarB;
                                                                                                                                                                     
public:
    //在派生類中對繼承的基類成員的初始化,需要由派生類的構(gòu)造函數(shù)調(diào)用基類的構(gòu)造函數(shù)來完成,這里可以用成員初始化列表來完成,這和初始化對象成員有類似之處。
    //B(派生類的參數(shù)列表):A(基類參數(shù)列表1),objA(基類參數(shù)列表2)
    //冒號后面的構(gòu)造函數(shù)成員初始化列表,每一個基類的構(gòu)造函數(shù)用逗號隔開,每項由基類名以及括號內(nèi)的參數(shù)列表組成,參數(shù)列表給出所調(diào)用的構(gòu)造函數(shù)以及所需的參數(shù),如果某個類使用的是無參數(shù)或者是缺省的構(gòu)造函數(shù),則該項可以不在成員初始化列表中出現(xiàn)。
    //當(dāng)說明一個A類的對象時,首先調(diào)用基類的構(gòu)造函數(shù),對基類成員進行初始化,然后才執(zhí)行派生類A自身的構(gòu)造函數(shù),如果某個基類仍然是一個派生類,則這個過程遞歸進行。當(dāng)該對象注銷時,析構(gòu)函數(shù)的執(zhí)行順序和執(zhí)行構(gòu)造函數(shù)的順序正好相反。
    //如果派生類中還有對象成員,則對對象成員的構(gòu)造函數(shù)的調(diào)用,仍然要在初始化列表中完成。
                                                                                                                                                                     
    B(int _iVarB,int _iVarA,int _objA):A(_iVarA),objA(_objA)
    {
        iVarB = _iVarB;
        cout<<"Construction B,iVarB = "<<iVarB<<endl;
    }
                                                                                                                                                                     
    ~B()
    {
        cout<<"Destorying B, iVarB = "<<iVarB<<endl;
    }
                                                                                                                                                                     
                                                                                                                                                                     
};
int main(int argc, const char * argv[])
{
    // insert code here...
    //如果有繼承,基類的構(gòu)造函數(shù)最先調(diào)用。
    B(1,4,5);
                                                                                                                                                                     
    return 0;
}

代碼下載地址:http://pan.baidu.com/share/link?shareid=1053220775&uk=3189484501

多重繼承和雙層繼承

#include <iostream>
using namespace std;
class Base
{
                                                                                               
public:
    Base()
    {
        cout<<"Construction Base"<<endl;
    }
    ~Base()
    {
        cout<<"Destorying Base"<<endl;
    }
};
class A
{
                                                                                               
public:
    A()
    {
        cout<<"Construction A"<<endl;
    }
    ~A()
    {
        cout<<"Destorying A"<<endl;
    }
};
class B:public Base
{
                                                                                               
public:
    B()
    {
        cout<<"Construction B"<<endl;
    }
    ~B()
    {
        cout<<"Destorying B"<<endl;
    }
};
class C
{
                                                                                               
public:
    C()
    {
        cout<<"Construction C"<<endl;
    }
    ~C()
    {
        cout<<"Destorying C"<<endl;
    }
};
class Object:public A ,public B , public C
{
                                                                                               
public:
    Object()
    {
        cout<<"Construction Object"<<endl;
    }
    ~Object()
    {
        cout<<"Destorying Object"<<endl;
    }
};
//在多重繼承中先執(zhí)行最先繼承的對象  例如:本例中的A
//在雙繼承中例如本例中的B類    B類是繼承自 Base  所以會先執(zhí)行Base
//在析構(gòu)函數(shù)的執(zhí)行順序與構(gòu)造函數(shù)的執(zhí)行順序相反
int main(int argc, const char * argv[])
{
    // insert code here...
    Object obj;
                                                                                               
    return 0;
}

代碼下載: http://pan.baidu.com/share/link?shareid=1098289671&uk=3189484501

多重繼承中的二義性

#include <iostream>
using namespace std;
class A
{
                                                                             
public:
    void Show()
    {
        cout<<"A"<<endl;
    }
};
class B
{
                                                                             
public:
    void Show()
    {
        cout<<"B"<<endl;
    }
    void Print()
    {
        cout<<"Print()B"<<endl;
    }
};
//多重繼承是指同時繼承多個,例如如下:
class Object:public A,public B
{
                                                                             
public:
    void Print()
    {
        cout<<"ObjectA||B"<<endl;
    }
    void ObjectShowA()
    {
        A::Show();
    }
    void ObjectShowB()
    {
        B::Show();
    }
};
//如果一個類是由兩個以上的類派生出來的,那么對基類成員的訪問必須是無二以性的。但是如果基類中含有相同名稱的成員,則訪問時可能產(chǎn)生二義性。
int main(int argc, const char * argv[])
{
    Object obj;
    //下面注釋的這種寫法會報錯因為會存在二義性
   // obj.Show();
    obj.A::Show();
    obj.Print();
    obj.B::Show();
    return 0;
}

代碼下載:  http://pan.baidu.com/share/link?shareid=1143818360&uk=3189484501

多層繼承的二義性

#include <iostream>
using namespace std;
//多層繼承: 如果一個派生類從多個基類中派生,并且這些基類又有一個共同的基類,則在這個派生類中訪問這個共同的基類中的成員時可能出現(xiàn)二義性。
class Base
{
                                                  
public:
    int iBaseData;
                                                  
};
class A:public Base
{
                                                  
public:
    int iAData;
};
class B:public Base
{
                                                  
public:
    int iBData;
};
class Object:public A,public B
{
                                                  
public:
    int iObjectData;
};
int main(int argc, const char * argv[])
{
    Object obj;
    obj.A::iBaseData = 10;
    obj.B::iBaseData = 20;
    cout<<"obj.A::iBaseData = "<<obj.A::iBaseData<<endl;
    cout<<"obj.B::iBData = "<<obj.B::iBaseData<<endl;
                                                
    return 0;
}

代碼下載:   http://pan.baidu.com/share/link?shareid=1208687701&uk=3189484501

虛基類

#include <iostream>
using namespace std;
//很顯然當(dāng)出現(xiàn)上節(jié)中的兩層繼承時,程序可能會出現(xiàn)二義性,如果能使這個公共基類只產(chǎn)生一個成員實例的話,很顯然就可以解決這個二義性的問題了,這時我們可以將這個基類說明虛基類的方式來解決這個問題,這就要求在Base類派生新類時,使用關(guān)鍵字virtual將Base類說明為虛基類
class Base
{
                           
public:
    int iBaseData;
    void Print()
    {
        cout<<"iBaseData = " << iBaseData<<endl;
                               
    }
};
class A:virtual public Base
{
                           
public:
    int iAData;
    void Print()
    {
        cout<<"In A iBaseData"<<iBaseData<<endl;
    }
};
class B:virtual public Base
{
                           
public:
    int iBate;
    void Print()
    {
        cout<<"In B iBaseData = "<<iBaseData<<endl;
    }
                           
};
class Object:public A , public B
{
                           
public:
    int iObjectData;
    void Print()
    {
        cout<<"In Object iBaseData = "<<iBaseData<<endl;
    }
};
//虛擬類可以使多層繼承中公共基類只產(chǎn)生一個實例,即在類Object中,Base類只有一個實例。
//這時obj.A::iBaseData == obj.B::iBaseData  == obj.Object::iBaseData
int main(int argc, const char * argv[])
{
                         
    Object obj;
    obj.iBaseData = 1000;
    obj.A::Print();
    obj.B::Print();
    obj.Base::Print();
    obj.Print();
                           
//繼承的幾點總結(jié):
//能用組合則不用繼承
//繼承的層數(shù)小于等于4層。
//盡量避免使用多重繼承
    return 0;
}

代碼下載:  http://pan.baidu.com/share/link?shareid=1294366574&uk=3189484501

另外有需要云服務(wù)器可以了解下創(chuàng)新互聯(lián)scvps.cn,海內(nèi)外云服務(wù)器15元起步,三天無理由+7*72小時售后在線,公司持有idc許可證,提供“云服務(wù)器、裸金屬服務(wù)器、高防服務(wù)器、香港服務(wù)器、美國服務(wù)器、虛擬主機、免備案服務(wù)器”等云主機租用服務(wù)以及企業(yè)上云的綜合解決方案,具有“安全穩(wěn)定、簡單易用、服務(wù)可用性高、性價比高”等特點與優(yōu)勢,專為企業(yè)上云打造定制,能夠滿足用戶豐富、多元化的應(yīng)用場景需求。

網(wǎng)站欄目:第二章繼承與派生-創(chuàng)新互聯(lián)
地址分享:http://bm7419.com/article20/ggjco.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián),為您提供定制開發(fā)網(wǎng)站建設(shè)、ChatGPT、服務(wù)器托管外貿(mào)建站、云服務(wù)器

廣告

聲明:本網(wǎng)站發(fā)布的內(nèi)容(圖片、視頻和文字)以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主,如果涉及侵權(quán)請盡快告知,我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場,如需處理請聯(lián)系客服。電話:028-86922220;郵箱:631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載,或轉(zhuǎn)載時需注明來源: 創(chuàng)新互聯(lián)

成都網(wǎng)站建設(shè)