C++继承介绍

 更新时间:2013年01月02日 17:35:04   作者:  
C++继承可以是单一继承或多重继承,每一个继承连接可以是public,protected,private也可以是virtual或non-virtual

然后是各个成员函数选项可以是virtual或non-virtual或pure virtual。本文仅仅作出一些关键点的验证。

  public继承,例如下:

复制代码 代码如下:

 class base
 {...}
 class derived:public base
 {...}  

如果这样写,编译器会理解成类型为derived的对象同时也是类型为base的对象,但类型为base的对象不是类型为derived的对象。这点很重要。那么函数形参为base类型适用于derived,形参为derived不适用于base。下面是验证代码,一个参数为base的函数,传入derived应该成功执行,相反,一个参数为derived的函数
复制代码 代码如下:

 #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;
 }

运行结果为:

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

下面改改代码,将函数参数变为derived

复制代码 代码如下:

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);
}

调用show(ss,d);编译器报错
复制代码 代码如下:

 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的成员在继承类里类型为表格里内容

复制代码 代码如下:

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私有函数而是base的私有函数
derived11.cpp:16: error: `std::string base::testPrivate()' is private
derived11.cpp:36: error: within this context这样验证private类型成员无法被继承(public,private,protected)注:private,protected略去不做证明
下面只要验证 testProtected 能被第三层继承类继承,但是无法被第三层类直接调用就说明是public继承后继承类型为protected,而基类为Public类型成员则即可被继承又可以直接调用。
复制代码 代码如下:

 #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;
}


这里服务器报错

derived12.cpp:13: error: `std::string base::testProtected()' is protected
derived12.cpp:62: error: within this context这样就验证了一个是public,一个是protected,protected是不能直接调用的,但是被继承后是可以被public成员调用的。
下面的已经证明,详细步骤就略去如果对该部分验证感兴趣,可以看下面代码。

复制代码 代码如下:

 #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;         //基类都是私有函数
    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;

相关文章

  • C++ map 根据value找key的实现

    C++ map 根据value找key的实现

    今天小编就为大家分享一篇C++ map 根据value找key的实现,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2019-12-12
  • 从汇编看c++中extern关键字的使用

    从汇编看c++中extern关键字的使用

    本篇文章介绍了,在c++中extern关键字的使用概述,需要的朋友参考下
    2013-05-05
  • strtok函数的使用示例

    strtok函数的使用示例

    今天小编就为大家分享一篇关于strtok函数的使用示例,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
    2018-12-12
  • C++begin和end运算符的返回迭代器的类型如何判断?

    C++begin和end运算符的返回迭代器的类型如何判断?

    今天小编就为大家分享一篇关于C++begin和end运算符的返回迭代器的类型如何判断?,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
    2019-04-04
  • c语言内存泄漏严重的解决方法

    c语言内存泄漏严重的解决方法

    这篇文章主要介绍了c语言内存泄漏的解决方法,帮助大家更好的理解和使用c语言开发,感兴趣的朋友可以了解下
    2020-09-09
  • C++ deque容器的用法详解

    C++ deque容器的用法详解

    在处理一些数组的事情,所以随手保留一下Deque容器的使用方法很有必要,接下来通过本文给大家重点介绍C++ deque容器的用法及deque和vector的区别讲解,感兴趣的朋友跟随小编一起看看吧
    2021-05-05
  • C语言学生成绩管理系统课程设计word版

    C语言学生成绩管理系统课程设计word版

    这篇文章主要为大家详细介绍了C语言学生成绩管理课程设计,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2020-12-12
  • C语言不定长数组及初始化方法

    C语言不定长数组及初始化方法

    今天小编就为大家分享一篇C语言不定长数组及初始化方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2018-07-07
  • C++&&Opencv实现控制台字符动画的方法

    C++&&Opencv实现控制台字符动画的方法

    这篇文章主要介绍了C++&&Opencv实现控制台字符动画的方法,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2020-07-07
  • C++中的函数汇总

    C++中的函数汇总

    这篇文章主要介绍了 C++中的函数汇总的相关资料,需要的朋友可以参考下
    2017-08-08

最新评论