C++继承与派生的访问基本规则

2024-05-07 18:18

本文主要是介绍C++继承与派生的访问基本规则,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

一 ,类的继承:继承分为单继承和多继承
继承的思想要点:继承中要点就是派生类和基类的初始化,都是调用基类的构造函数来实现的,接下来就是函数的实现及类的作用域问题值得注意。
      首先注意构造函数和析构函数都不能继承:因此要用通过调用基类的构造函数来初始化基类的数据成员。
      派生类构造函数调用原则是:先基类,后子对象,再派生类。
      派生类析构函数调用原则是:先派生类,后子对象,再基类。过程刚好与派生类的构造函数相反。

    

 (1)单继承: class  派生类名:继承方式 基类  {类体};



      构造函数的初始化方法:派生类名::派生类名(总参数表):基类构造函数(参数表),子对象(参数表),派生类中新成员(参数表){  派生类新元素  }


例子:class A {public: int a , b;}; class B: public A { private: A aa;};

B::B(int i , int j , int k):A(i,j),aa(j,k){}

     

(2)多继承:class 派生类名:继承方式1   基类名 , 继承方式2  基类名{类体};


多集成的构造函数: 派生类名::派生类名(总参数表):当前直接基类名1(参数1),当前直接基类名2(参数2),子对象(参数表){   派生类新元素   }
     例子:class A {  private:   int a; };   class B { private : int b;};
     class C: public A ,public B { public: C(int i , int j , int k ); private : int c};
     派生类C的构造函数初始化格式:C::C(int i, int j , int k):A(i),B(j),c(k){ }
     或者 C::C(int i, int j , int k):A(i),B(j){ c = k; }


(3)多继承中访问存在的二义性问题: <1>多个基类之间存在同名函数时,在调用过程中会出现调用错误。解决方法是用类作用域符进行限制函数所属的类。
例子:class A   {  public :void print(); };
class B {public: void print();};
class C:public A, public B
int main()
{ C aa;   aa.A::print(); aa.B::print(); }


 <2>多继承时不同基类有公共基类时存在二义性:解决方法是采用虚基类。
      虚基类的定义方法: class 派生类名:virtual   继承方式  基类名


虚基类继承方式的派生类构造函数初始化: class 派生类名::派生类名(总参数表): 当前直接继承的类1(参数表1), 当前直接继承的类2(参数表2),原始基类(原始基类参数表){ 派生类新元素 }


例子:class A {private char *s ;};    //基类A  
class B:virtual  public A; //派生类B 虚继承类A
  class C: virtual public A;  //派生类C 虚继承类A  
  class D:public B , public C; //派生类D 继承类B,继承类C 
//下面是派生类D构造函数的初始化方式
D::D(char *s1 , char *s2 ,char *s3 ,char *s4):B(s1,s2),C(s1,s3),A(s1){   strcpy(str,s4); }


二,多继承的实例:
   概述有些报文需要多个结构体或者多个类,并多次继承多个类而形成的报文,这种的类型的类之间的继承,有一个最终思想就是:先把当前继承的类的总参数表做好,在根据当前的基类对其当前的基类传参数,接下来是派生类的新成员,之后再{}内,要把上一层的基类的数据成员进行构造的初始化,(即参数细化到最初的那个基类中才算完成)。
例子:typedef struct wmmphead
{
        unsigned short command;
        unsigned int cmdlen;
} wmmphead;
typedef struct wmmpbodyinfo
{
        string url;
        unsigned int command;
        unsigned short size;
        map<string,int>mtlv;
} wmmpbodyinfo;
class wmmpmesg
{
        public:
        wmmphead *msg_head;
        wmmpmesg( wmmphead *head):msg_head(head){   cout<<"wmmphead *msg_head ="<<(void*)msg_head<<endl;}
        virtual ~wmmpmesg(){}
};
class wmmp3msg
{
        public:
        wmmpmesg header;
        map<string,int> *p_tlv;
//下面的可改为 wmmp3msg( wmmphead *head ):header(head)    
    wmmp3msg( wmmphead *head,  map<string,int> *maptlv):header(head),p_tlv(maptlv)
        { cout<<" map<string,int> *p_tlv = "<<(void *)p_tlv<<endl; }


        virtual ~wmmp3msg(){}
};
class WMMPprotocl:wmmp3msg
{
        public:
        wmmpbodyinfo *bodyinfo;
//下面的构造函数说明只关心当前派生类所继承的基类的参数,而不是追加到上上一层的基类
//下面的可改为 WMMPprotocl(wmmphead *head, wmmpbodyinfo *body):wmmp3msg(head),bodyinfo(body)
{    header.msg_head = head; p_tlv = &(body->mtlv);   }
//
        WMMPprotocl(wmmphead *head, wmmpbodyinfo *body, map<string,int> *mapiter):wmmp3msg(head,mapiter),bodyinfo(body)
   {    //header.msg_head = head; p_tlv = &(body->mtlv); //这里体现了参数细化到最初的那个基类             header.msg_head = head; p_tlv = mapiter;
                cout<<" map<string,int> *p_tlv ="<<(void*)p_tlv<<endl;
                 cout<<"wmmpbodyinfo *bodyinfo="<<(void*)bodyinfo<<endl; }
        virtual ~WMMPprotocl(){}
};
int main()
{
wmmphead* head = new wmmphead();
head->command = 12345;
head->cmdlen = 20;
cout<<" wmmphead* head = "<<(void *)head<<endl;
wmmpbodyinfo *body = new wmmpbodyinfo();
cout<<"wmmpbodyinfo *body = "<<(void*)body<<endl;
map<string,int> *mapiter = &(body->mtlv);
 WMMPprotocl *prt = new WMMPprotocl( head, body, mapiter) ;
 prt->bodyinfo->url = "www.baidu.com";
 prt->bodyinfo->command = 11111;
 prt->bodyinfo->size = 2222;
 prt->bodyinfo->mtlv["qiwie"] =3333;
 cout<<"WMMPprotocl *prt= "<<(void *)prt<<endl;
cout<<"head->command="<<head->command<<endl;
cout<<"head->cmdlen="<<head->cmdlen<<endl;
cout<<"body->url="<<body->url<<endl;
cout<<"body->command="<<body->command<<endl;
cout<<"body->size="<<body->size<<endl;
cout<<"body->mtlv="<<body->mtlv["qiwie"]<<endl;
 return 0;
}
结果如下:
 wmmphead* head = 0xefdb010
wmmpbodyinfo *body = 0xefdb030
wmmphead *msg_head =0xefdb010
 map<string,int> *p_tlv = 0xefdb040
 map<string,int> *p_tlv =0xefdb040
wmmpbodyinfo *bodyinfo=0xefdb030
WMMPprotocl *prt= 0xefdb080
head->command=12345
head->cmdlen=20
body->url=www.baidu.com
body->command=11111
body->size=2222
body->mtlv=3333


C++中派生类对基类成员的访问形式主要有以下两种:



1、内部访问:由派生类中新增成员对基类继承来的成员的访问。

2、对象访问:在派生类外部,通过派生类的对象对从基类继承来的成员的访问。


今天给大家介绍在3中继承方式下,派生类对基类成员的访问规则。


公有继承(public)、私有继承(private)、保护继承(protected)是常用的三种继承方式。

1. 公有继承(public)

公有继承的特点是基类的公有成员和保护成员作为派生类的成员时,它们都保持原有的状态,而基类的私有成员仍然是私有的,不能被这个派生类的子类所访问。

2. 私有继承(private)

私有继承的特点是基类的公有成员和保护成员都作为派生类的私有成员,并且不能被这个派生类的子类所访问。

3. 保护继承(protected)

保护继承的特点是基类的所有公有成员和保护成员都成为派生类的保护成员,并且只能被它的派生类成员函数或友元访问,基类的私有成员仍然是私有的。

下面列出三种不同的继承方式的基类特性和派生类特性。

  public protected private
共有继承 public protected 不可见
私有继承 private private 不可见
保护继承 protected protected 不可见

在上图中:1)基类成员对派生类都是:共有和保护的成员是可见的,私有的的成员是不可见的。

                   2)基类成员对派生类的对象来说:要看基类的成员在派生类中变成了什么类型的成员。如:私有继承时,基类的共有成员和私有成员都变成了派生类中的私有成员,因此对于派生类中的对象来说基类的共有成员和私有成员就是不可见的。

  为了进一步理解三种不同的继承方式在其成员的可见性方面的区别,下面从三种不同角度进行讨论。

对于公有继承方式

(1) 基类成员对其对象的可见性:

公有成员可见,其他不可见。这里保护成员同于私有成员。

(2) 基类成员对派生类的可见性:

公有成员和保护成员可见,而私有成员不可见。这里保护成员同于公有成员。

(3) 基类成员对派生类对象的可见性:

公有成员可见,其他成员不可见。

所以,在公有继承时,派生类的对象可以访问基类中的公有成员;派生类的成员函数可以访问基类中的公有成员和保护成员。这里,一定要区分清楚派生类的对象和派生类中的成员函数对基类的访问是不同的。

对于私有继承方式

(1) 基类成员对其对象的可见性:

公有成员可见,其他成员不可见。

(2) 基类成员对派生类的可见性:

公有成员和保护成员是可见的,而私有成员是不可见的。

(3) 基类成员对派生类对象的可见性:

所有成员都是不可见的。

所以,在私有继承时,基类的成员只能由直接派生类访问,而无法再往下继承。

对于保护继承方式

这种继承方式与私有继承方式的情况相同。两者的区别仅在于对派生类的成员而言,对基类成员有不同的可见性。

上述所说的可见性也就是可访问性。

关于可访问性还有另的一种说法。这种规则中,称派生类的对象对基类访问为水平访问,称派生类的派生类对基类的访问为垂直访问。

看看这样的例子

#include<iostream>
using  namespace  std;
//
class  A       //父类
{
private :
     int  privatedateA;
protected :
     int  protecteddateA;
public :
     int  publicdateA;
};
//
class  B : public  A      //基类A的派生类B(共有继承)
{
public :
     void  funct()
     {
         int  b;
         b=privatedateA;   //error:基类中私有成员在派生类中是不可见的
         b=protecteddateA; //ok:基类的保护成员在派生类中为保护成员
         b=publicdateA;    //ok:基类的公共成员在派生类中为公共成员
     }
};
//
class  C : private  //基类A的派生类C(私有继承)
{
public :
     void  funct()
     {
         int  c;
         c=privatedateA;    //error:基类中私有成员在派生类中是不可见的
         c=protecteddateA;  //ok:基类的保护成员在派生类中为私有成员
         c=publicdateA;     //ok:基类的公共成员在派生类中为私有成员
     }
};
//
class  D : protected  A   //基类A的派生类D(保护继承)
{
public :
     void  funct()
     {
         int  d;
         d=privatedateA;   //error:基类中私有成员在派生类中是不可见的
         d=protecteddateA; //ok:基类的保护成员在派生类中为保护成员
         d=publicdateA;    //ok:基类的公共成员在派生类中为保护成员
     }
};
//
int  main()
{
     int  a;
     B objB;
     a=objB.privatedateA;   //error:基类中私有成员在派生类中是不可见的,对对象不可见
     a=objB.protecteddateA; //error:基类的保护成员在派生类中为保护成员,对对象不可见
     a=objB.publicdateA;    //ok:基类的公共成员在派生类中为公共成员,对对象可见
     C objC;
     a=objC.privatedateA;   //error:基类中私有成员在派生类中是不可见的,对对象不可见
     a=objC.protecteddateA; //error:基类的保护成员在派生类中为私有成员,对对象不可见
     a=objC.publicdateA;    //error:基类的公共成员在派生类中为私有成员,对对象不可见
     D objD;
     a=objD.privatedateA;   //error:基类中私有成员在派生类中是不可见的,对对象不可见
     a=objD.protecteddateA; //error:基类的保护成员在派生类中为保护成员,对对象不可见
     a=objD.publicdateA;    //error:基类的公共成员在派生类中为保护成员,对对象不可见
     return  0;
}

这篇关于C++继承与派生的访问基本规则的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/968029

相关文章

Nginx location匹配模式与规则详解

《Nginxlocation匹配模式与规则详解》:本文主要介绍Nginxlocation匹配模式与规则,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、环境二、匹配模式1. 精准模式2. 前缀模式(不继续匹配正则)3. 前缀模式(继续匹配正则)4. 正则模式(大

C++如何通过Qt反射机制实现数据类序列化

《C++如何通过Qt反射机制实现数据类序列化》在C++工程中经常需要使用数据类,并对数据类进行存储、打印、调试等操作,所以本文就来聊聊C++如何通过Qt反射机制实现数据类序列化吧... 目录设计预期设计思路代码实现使用方法在 C++ 工程中经常需要使用数据类,并对数据类进行存储、打印、调试等操作。由于数据类

Linux下如何使用C++获取硬件信息

《Linux下如何使用C++获取硬件信息》这篇文章主要为大家详细介绍了如何使用C++实现获取CPU,主板,磁盘,BIOS信息等硬件信息,文中的示例代码讲解详细,感兴趣的小伙伴可以了解下... 目录方法获取CPU信息:读取"/proc/cpuinfo"文件获取磁盘信息:读取"/proc/diskstats"文

C++使用printf语句实现进制转换的示例代码

《C++使用printf语句实现进制转换的示例代码》在C语言中,printf函数可以直接实现部分进制转换功能,通过格式说明符(formatspecifier)快速输出不同进制的数值,下面给大家分享C+... 目录一、printf 原生支持的进制转换1. 十进制、八进制、十六进制转换2. 显示进制前缀3. 指

C++中初始化二维数组的几种常见方法

《C++中初始化二维数组的几种常见方法》本文详细介绍了在C++中初始化二维数组的不同方式,包括静态初始化、循环、全部为零、部分初始化、std::array和std::vector,以及std::vec... 目录1. 静态初始化2. 使用循环初始化3. 全部初始化为零4. 部分初始化5. 使用 std::a

MySQL 中的 LIMIT 语句及基本用法

《MySQL中的LIMIT语句及基本用法》LIMIT语句用于限制查询返回的行数,常用于分页查询或取部分数据,提高查询效率,:本文主要介绍MySQL中的LIMIT语句,需要的朋友可以参考下... 目录mysql 中的 LIMIT 语句1. LIMIT 语法2. LIMIT 基本用法(1) 获取前 N 行数据(

C++ vector的常见用法超详细讲解

《C++vector的常见用法超详细讲解》:本文主要介绍C++vector的常见用法,包括C++中vector容器的定义、初始化方法、访问元素、常用函数及其时间复杂度,通过代码介绍的非常详细,... 目录1、vector的定义2、vector常用初始化方法1、使编程用花括号直接赋值2、使用圆括号赋值3、ve

如何高效移除C++关联容器中的元素

《如何高效移除C++关联容器中的元素》关联容器和顺序容器有着很大不同,关联容器中的元素是按照关键字来保存和访问的,而顺序容器中的元素是按它们在容器中的位置来顺序保存和访问的,本文介绍了如何高效移除C+... 目录一、简介二、移除给定位置的元素三、移除与特定键值等价的元素四、移除满足特android定条件的元

Python获取C++中返回的char*字段的两种思路

《Python获取C++中返回的char*字段的两种思路》有时候需要获取C++函数中返回来的不定长的char*字符串,本文小编为大家找到了两种解决问题的思路,感兴趣的小伙伴可以跟随小编一起学习一下... 有时候需要获取C++函数中返回来的不定长的char*字符串,目前我找到两种解决问题的思路,具体实现如下:

C++ Sort函数使用场景分析

《C++Sort函数使用场景分析》sort函数是algorithm库下的一个函数,sort函数是不稳定的,即大小相同的元素在排序后相对顺序可能发生改变,如果某些场景需要保持相同元素间的相对顺序,可使... 目录C++ Sort函数详解一、sort函数调用的两种方式二、sort函数使用场景三、sort函数排序