快捷導(dǎo)航

C++繼承介紹

更新時間：2013年01月02日 17:35:04 作者：

C++繼承可以是單一繼承或多重繼承，每一個繼承連接可以是public,protected,private也可以是virtual或non-virtual

然后是各個成員函數(shù)選項可以是virtual或non-virtual或pure virtual。本文僅僅作出一些關(guān)鍵點的驗證。

　　public繼承，例如下：

 class base
 ｛...｝
 class derived:public base
 ｛...｝　　

如果這樣寫，編譯器會理解成類型為derived的對象同時也是類型為base的對象，但類型為base的對象不是類型為derived的對象。這點很重要。那么函數(shù)形參為base類型適用于derived，形參為derived不適用于base。下面是驗證代碼，一個參數(shù)為base的函數(shù)，傳入derived應(yīng)該成功執(zhí)行，相反，一個參數(shù)為derived的函數(shù)

復(fù)制代碼代碼如下:

 #include <iostream>
  #include <stdio.h>

  class base
  {
      public:
      base()
      :baseName(""),baseData(0)
      {}

     base(std::string bn,int bd)
     :baseName(bn),baseData(bd)
     {}

     std::string getBaseName() const
     {
         return baseName;
     }

     int getBaseData()const
     {
         return baseData;
     }

     private:
         std::string baseName;
         int baseData;
 };

 class derived:public base
 {
     public:
         derived():base(),derivedName("")
         {}
         derived(std::string bn,int bd,std::string dn)
         :base(bn,bd),derivedName(dn)
         {}
         std::string getDerivedName() const
         {
             return derivedName;
         }
     private:
         std::string derivedName;
 };

 void show(std::string& info,const base& b)
 {
     info.append("Name is ");
     info.append(b.getBaseName());
     info.append(", baseData is ");
     char buffer[10];
     sprintf(buffer,"%d",b.getBaseData());
         info.append(buffer);
 }

 int main(int argc,char* argv[])
 {
     base b("test",10);
     std::string s;
     show(s,b);
     std::cout<<s<<std::endl;
     derived d("btest",5,"dtest");
     std::string ss;
     show(ss,d);
     std::cout<<ss<<std::endl;
     return 0;
 }

運行結(jié)果為：

base:baseName is test, baseData is 10
base:baseName is btest, baseData is 5

下面改改代碼，將函數(shù)參數(shù)變?yōu)閐erived

復(fù)制代碼代碼如下:

void show2(std::string& info,const derived& d)
{
    info.append("Name is ");
    info.append(d.getBaseName());
    info.append(", baseData is ");
    char buffer[10];
    sprintf(buffer,"%d",d.getBaseData());
    info.append(buffer);
}

調(diào)用show(ss,d);編譯器報錯

復(fù)制代碼代碼如下:

 derived_class.cpp: In function `int main(int, char**)':
 derived_class.cpp:84: error: invalid initialization of reference of type 'const derived&' from expression of type 'base'
 derived_class.cpp:70: error: in passing argument 2 of `void show2(std::string&, const derived&)'第二點對各種形式的繼承作出驗證，首先給出表格

繼承方式\成員類型	public	protected	private
public	public	protected	無法繼承
protected	protected	protected	無法繼承
private	private	private	無法繼承

這里解釋一下，這里僅僅表達基類的成員，被public,protected,private三種方式繼承后，在原基類為public,protectedc,private的成員在繼承類里類型為表格里內(nèi)容

復(fù)制代碼代碼如下:

class base
{
    public:
        std::string testPublic()
        {
            return std::string("this is public base");
        }
    protected:
        std::string testProtected()
       {
           return std::string("this is protected base");
       }
   private:
       std::string testPrivate()
       {
           return std::string("this is private base");
       }
};
class derivedPublic:public base
{
   public:
       std::string testPubPublic()
       {
           return testPublic()+= "in derived";
       }
       std::string testProPublic()
       {    
           return testProtected()+= "in derived";
       }
       std::string testPriPublic()                   
       {    
           return testPrivate()+= "in derived";
       }
};
int main(int argc,char* argv[])
｛
   derivedPublic dpub;
   std::cout << dpub.testPublic() << std::endl; 
｝

報下面錯誤，說明testPrivate()不是derived私有函數(shù)而是base的私有函數(shù)
derived11.cpp:16: error: `std::string base::testPrivate()' is private
derived11.cpp:36: error: within this context這樣驗證private類型成員無法被繼承（public,private,protected）注：private，protected略去不做證明
下面只要驗證 testProtected 能被第三層繼承類繼承，但是無法被第三層類直接調(diào)用就說明是public繼承后繼承類型為protected，而基類為Public類型成員則即可被繼承又可以直接調(diào)用。

復(fù)制代碼代碼如下:

#include <iostream>
#include <string>

class base
{
     public:
         std::string testPublic()
         {
             return std::string("this is public base");
        }
    protected:
        std::string testProtected()
        {
            return std::string("this is protected base");
        }
    private:
        std::string testPrivate()
        {
            return std::string("this is private base");
        }
};

class derivedPublic:public base
{
    public:
        std::string testPubPublic()
        {
            return testPublic()+= "in derived";
        }

        std::string testProPublic()
        {
            return testProtected()+= "in derived";
        }

//        std::string testPriPublic()
//        {
//            return testPrivate()+= "in derived";
//        }
};

class deepDerived:public derivedPublic
{
    public:
        std::string deepProtected()
        {
            return testProtected() +="in deep";
        }

        std::string deepPublic()
        {
            return testPublic() +="indeep";
        }
};

int main(int argc,char* argv[])
{
    derivedPublic dpub;
    std::cout << dpub.testProtected() << std::endl;
    deepDerived deepdpub;
    std::cout<<deepdpub.testPublic() <<std::endl;
    std::cout<<deepdpub.testProtected() <<std::endl;
    std::cout<<deepdpub.deepProtected() <<std::endl;
    std::cout<<deepdpub.deepPublic() <<std::endl;
}

這里服務(wù)器報錯

derived12.cpp:13: error: `std::string base::testProtected()' is protected
derived12.cpp:62: error: within this context這樣就驗證了一個是public，一個是protected，protected是不能直接調(diào)用的，但是被繼承后是可以被public成員調(diào)用的。
下面的已經(jīng)證明，詳細步驟就略去如果對該部分驗證感興趣，可以看下面代碼。

復(fù)制代碼代碼如下:

 #include <iostream>
 2 #include <string>
 3 class base
 4 {
 5     public:
 6         std::string testPublic()
 7         {
 8             return std::string("this is public base");
 9         }
     protected:
         std::string testProtected()
         {
             return std::string("this is protected base");
         }
     private:
         std::string testPrivate()
         {
             return std::string("this is private base");
         }
 };

 class derivedPublic:public base
 {
     public:
         std::string testPubPublic()
         {
             return testPublic()+= "in derived";
         }

         std::string testProPublic()
         {    
             return testProtected()+= "in derived";
         }

 //        std::string testPriPublic()                   //私有成員并沒有被繼承下來
 //        {    
 //            return testPrivate()+= "in derived";
 //        }
 };

 class deepDerived:public derivedPublic
 {
     public:
         std::string test()
         {
             return testPublic() +="in 3";
         }
 };

 class derivedProtected:protected base
 {
     public:
         std::string testPubProtected()
         {
             return testPublic()+= "in derived";
         }

         std::string testProProtected()
         {    
             return testProtected()+= "in derived";
         }
 };

 class deepDerived2:public derivedProtected
 {
     public:
         std::string test()
         {
             return testPublic() +="in 3";
         }
 };

 class derivedPrivate:private base
 {
     public:
         std::string testPubPirvate()
         {
             return testPublic()+= "in derived";
         }

         std::string testProPrivate()
         {    
             return testProtected()+= "in derived";
         }

 };

 //class deepDerived3:public derivedPrivate
 //{
 //    public:
 //        std::string test()
 //        {
 //            return testPublic() +="in 3";
 //        }
 //};

 int main(int argc,char* argv[])
 {
     derivedPublic dpub;
    //derivedProtected dpro;
    //derivedPrivate dpri;
    std::cout<<dpub.testPublic()<<std::endl;       //
    //std::cout<<dpub.testProtected()<<std::endl;    //用戶被繼承也是無法使用
    //cout<<dpub.testPrivate()<<std::endl;         //基類都是私有函數(shù)
    std::cout<<dpub.testPubPublic()<<std::endl;
    std::cout<<dpub.testProPublic()<<std::endl;
    //std::cout<<dpub.testPriPrivate()<<std::endl; //沒有被繼承

    deepDerived dd;
    std::cout<<dd.test()<<std::endl;

    derivedProtected dpro;
    //std::cout<<dpro.testPublic()<<std::endl;        //變成protected類型
    std::cout<<dpro.testPubProtected()<<std::endl;
    std::cout<<dpro.testProProtected()<<std::endl;

    deepDerived2 dd2;
    std::cout<<dd2.test()<<std::endl;

    derivedPrivate dpri;
    std::cout<<dpri.testPubPirvate()<<std::endl;
    std::cout<<dpri.testProPrivate()<<std::endl;

//    deepDerived3 dd3;
//    std::cout<<dd3.test()<<std::endl;
｝