抛弃的多重继承

最新推荐文章于 2022-05-07 20:18:51 发布
最新推荐文章于 2022-05-07 20:18:51 发布
阅读量84 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41936794/article/details/104915936
版权

在这里插入图片描述C++语言是支持多继承的,这在java,C#是支持不允许多继承的
一个子类可以拥有多个子类
子类拥有所有父类的成员变量
子类继承所有父类的成员函数
子类对象可以当作任意父类对象使用
语法规则：

class Derived: public Base A,
               public Base B,
               public Base C,
{

};

多重继承带来的第一个问题

例子：

#include <iostream>
#include <string>
using namespace std;
class A
{
  private:
  int mA;
  public:
  A(int a)
  {
     mA = a;
  }
  int getA()
  {
    return mA;
  }
};
class B
{
  private:
  int mB;
  public:
  B(int b)
  {
     mB = b;
  }
  int getB()
  {
    return mB;
  }
};
class C : public B,public A
{
  private:
  int mC;
  public:
  C(int a,int b,int c) : B(b),A(a)
  {
     mC = c;
  }
  int getC()
  {
    return mC;
  } 
  void  print()
  {
    cout<<"ma = "<<getA()<<","
        <<"mb = "<<getB()<<","
        <<"mc = "<<mC<<endl;
  }
};
int main()
{
  cout<<"sizeof(c) ="<<sizeof(C)<<endl;
  C c(1,2,3);
  c.print();
  return 0;
}

结果：

sice@sice:~$ ./a.out 
sizeof(c) =12
ma = 1,mb = 2,mc = 3

之前我们说在一个类里面成员变量和成员函数是分开存放的,每一个类对象都有自己的成员变量但是共享成员函数,sizeof©=12就是三个int类型变量的字节数
改进上述代码的main函数

int main()
{
  cout<<"sizeof(c) ="<<sizeof(C)<<endl;
  C c(1,2,3);
  c.print();
  
  A *pa   = &c;
  B *pb  = &c;
  
  cout<<endl;
  
  cout<<"pa->getA()"<<pa->getA()<<endl;
  cout<<"pb->getB()"<<pb->getB()<<endl;
  cout<<endl;
  
  void *paa = pa;
  void *pbb = pb;
  if( paa == pbb )
  {
     cout << "Pointer to the same object!" << endl; 
  }
  else
  {
      cout << "Error" << endl;
  }
    
  cout << "p = " << pa << endl;
  cout << "pb = " << pb << endl;
  cout << "paa = " << paa << endl;
  cout << "pbb = " << pbb << endl; 
    
  return 0;
}

结果:

sizeof(c) =12
ma = 1,mb = 2,mc = 3
p->getA()1
pb->getB()2
Error
p = 0xbff06958
pb = 0xbff06954
paa = 0xbff06958
pbb = 0xbff06954

可以看出父类指针指向子类时只能访问父类中的成员函数,但是这里的为什么打印的地址不同呢?这是因为通过多继承得到的对象可能拥有"不同地址"！！,这是C++的特性,无解决方案,只能人工判断
在这里插入图片描述

多重继承带来的第二个问题在这里插入图片描述

多重继承可能会产生多余的成员,比如上图的Doctor类继承了Teacher类和Student类,就变成了两个name和两个age,当多重继承关系出现闭合时将产生数据多余的问题
解决方案:虚继承

class People{};
class Teacher : virtual public People{};
class Student : virtual public People{};
class Doctor:public Teadcher,public Student
{};

虚继承能够解决数据多余问题
中间层父类不再关心顶层父类的初始化
最终子类必须直接调用顶层父类的构造函数,必须找到父类,麻烦
虚继承使得架构设计可能出现问题！！
例子(不参用虚继承)：

string>
using namespace std;
class People
{
   string m_name;
   int m_age;
   public:
   People(string name,int  age)
   {
     m_name = name;
     m_age  = age;
     cout<<"People(string name,int  age)"<<endl;
   }
   void print()
   {
     cout<<"the name is "<<m_name<<endl;
     cout<<"the age  is "<<m_age<<endl;
   }
};
class Teacher : virtual public People
{
   public:
   Teacher(string name,int  age): People(name,age)
   {
       cout<<"Teacher(string name,int  age)"<<endl;
   }
};
class Student :virtual public People
{
   public:
   Student(string name,int age): People(name,age)
   {
      cout<<"Student(string name,int age)"<<endl;
   }
};
class Doctor : public Teacher,public Student
{
   public:
   Doctor(string name,int age):Teacher(name, age),Student(name, age),People(name, age)
   {
       cout<<"Doctor(string name,int age)"<<endl;
   }
};
int main()
{  
   Doctor d("Li",33);
   d.print();
   return 0;
}

结果：

People(string name,int  age)
Teacher(string name,int  age)
People(string name,int  age)
Student(string name,int age)
Doctor(string name,int age)
the name is Li
the age  is 33
the name is Li
the age  is 33

例子(用虚继承)：

#include <iostream> 
#include <string>
using namespace std;
class People
{
   string m_name;
   int m_age;
   public:
   People(string name,int  age)
   {
     m_name = name;
     m_age  = age;
     cout<<"People(string name,int  age)"<<endl;
   }
   void print()
   {
     cout<<"the name is "<<m_name<<endl;
     cout<<"the age  is "<<m_age<<endl;
   }
};
class Teacher :virtual  public People
{
   public:
   Teacher(string name,int  age): People(name,age)
   {
       cout<<"Teacher(string name,int  age)"<<endl;
   }
};
class Student :virtual  public People
{
   public:
   Student(string name,int age): People(name,age)
   {
      cout<<"Student(string name,int age)"<<endl;
   }
};
class Doctor : public Teacher,public Student
{
   public:
   Doctor(string name,int age):Teacher(name,age),Student(name,age),People(name,age)
   {
       cout<<"Doctor(string name,int age)"<<endl;
   }
 };
int main()
{  
   Doctor d("Li",33);
   d.print();
   return 0;
}

结果:

People(string name,int  age)
Teacher(string name,int  age)
Student(string name,int age)
Doctor(string name,int age)
the name is Li
the age  is 33

可以看出使用虚继承,中间层父类不再关心顶层父类的初始化,最终子类直接调用父类的构造函数,但是这在大工程是没必要存在的

多重继承可能会产生多个虚函数表

在这里插入图片描述

例子：

#include <iostream>
#include <string>
using  namespace std;
class A
{
   public:
   virtual void funA()
   {
      cout<<"funA()"<<endl;
   }
};
class B
{
   public:
   virtual void funB()
   {
      cout<<"funB()"<<endl;
   }
};
class C: public A,public B
{
};
int main()
{
  C c;
  cout<<"sizeof(c)"<<sizeof(c)<<endl;
  A *a  = &c;
  B *b  = &c;
  B *bb = (B*)a;
  a->funA();
  b->funB();
  bb->funB();
}
```‘
结果:

```bash
sice@sice:~$ ./a.out 
sizeof(c)8
funA()
funB()
funA()

对于上面sizeof©==8大家应该不会觉得奇怪,因为C类继承了两个虚函数指针,有疑问的是为什么bb->funB()打印的是funA()呢？这是因为强制类型转化而造成的,见下图,pa,pb指向的虚函数表的结构是一样的,所以将(BaseA*)类型的指针强制转化为(BaseB*)类型的指针属于同类型指针转化是不会出错的,所以pbb指向和pa相同的位置,也就是说因为虚函数表的结构一样, B bb = (B)变成了A bb = (A)a,在C++中我们要忘记这种方式

在这里插入图片描述

改进：

int main()
{
  C c;
  cout<<"sizeof(c)"<<sizeof(c)<<endl;
  A *a  = &c;
  B *b  = &c;
  B *bb = dynamic_cast<B*>(a);
  a->funA();
  b->funB();
  bb->funB();
}

结果：

sice@sice:~$ ./a.out 
sizeof(c)8
funA()
funB()
funB()

这个时候由于使用了dynamic_cast关键字,编译器就会检查a指向的对象是c,发现c的父类有A和B,所以指针强制类型转化是可以通过的,再使bb指向b所指的位置,显然调用了funB()函数,如果说我们遇上需要强制类型转化的类,类里面又定义了虚函数,我们就使用dynamic_cast关键字

在实际的工程中我们采用“单继承加接口的形式”

在这里插入图片描述
代码：

#include <iostream>
#include <string>

using namespace std;

class BaseA
{
public:
    virtual void funcA()
    {
        cout << "BaseA::funcA()" << endl;
    }
};

class BaseB
{
public:
    virtual void funcB()
    {
        cout << "BaseB::funcB()" << endl;
    }
};

class Derived : public BaseA, public BaseB
{

};

int main()
{
    Derived d;
    BaseA* pa = &d;
    BaseB* pb = &d;
    BaseB* pbe = (BaseB*)pa;    // oops!!
    BaseB* pbc = dynamic_cast<BaseB*>(pa);
    
    cout << "sizeof(d) = " << sizeof(d) << endl;
    
    cout << "Using pa to call funcA()..." << endl;
    
    pa->funcA();
    
    cout << "Using pb to call funcB()..." << endl;
    
    pb->funcB();
    
    cout << "Using pbc to call funcB()..." << endl;
    
    pbc->funcB();
    
    cout << endl;
    
    cout << "pa = " << pa << endl;
    cout << "pb = " << pb << endl;
    cout << "pbe = " << pbe << endl;
    cout << "pbc = " << pbc << endl;
    
    return 0;
}

在这里插入图片描述

在这里插入图片描述

勇士后卫头盔哥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 多重继承
xiaogangjava的博客
11-29 4912
C++ 编程语言技术知识积累
C++学习笔记22 关于多重继承 接口
CppPlayer
09-08 1016
C++在语法上直接支持多重继承
多重继承(MI)
qq_36314864的博客
12-14 1361
worker0.h #ifndef WORKER0_H_ #define WORKER0_H_ #include <string> class Worker { private: std::string fullname; long id; public: Worker() : fullname("no one"), id(0L) {} Worker(const std::string & s, long n) : fullname(s), id(n) {} virtu
c++笔记 ---- 多重继承-虚基类
名字决定高度
08-05 425
多重继承-虚基类多重继承具有相同祖先的普通基类继承具有相同祖先的虚基类继承虚基类声明关于虚基类合理的创建标题，有助于目录的生成如何改变文本的样式如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 多重继承 多重继承也成MI，描述的是有多个直接基类的类。和单继承一样，公有MI表示的也是is-a关系。必须使用关
java为什么抛弃多类继承?
samfang的专栏
04-14 636
<br />主要是Java设计者希望Java是一个简单,友好的面向对象语言. 另外历史经验也表明C++的多类继承带来的复杂度远大于其好处.<br /> <br />Q: Why is multiple inheritance not provided in Java?<br /><br /> A: One of the main reasons for creating Java was to address the problems of C++. One such problem was multip
P34-c++中的代码重用-03多重继承详细介绍
梦悦foundation
02-22 280
文章目录1. 多重继承2. 有多少 Worker3. 虚基类4. 新的构造函数规则5. 哪个方法6. 混合使用虚基类和非虚基类7. 虚基类和支配8. MI小结 1. 多重继承 MI描述的是有多个直接基类的类。与单继承一样,公有MI表示的也是is-a关系。 例如,可以从 Waiter类和 Singer类派生出 SingingWaiter类 class SingingWaiter : public Waiter, public Singer {}; 请注意,必须使用关键字 public来限定每一个基类。这是因
第19课 - 专题三经典问题解析（多重继承/多态与数组）
qq_36521904的博客
05-28 192
第19课 - 专题三经典问题解析 一.当多态遇见对象数组会发生什么？ 1.1 指针的运算时通过指针的类型进行的，在编译时进行的 1.2 多态通过虚函数表实现的，在程序运行时进行的 Source Example 1： #include &lt;iostream&gt; /* run this program us...
JAVA基础编程——继承
止步听风的博客
05-07 1027
面向对象的三大特性是封装、继承和多态。
经典问题解析（3）---多态与数组、多重继承、接口的概念
ZhY_Rening的博客
02-24 460
经典问题解析（3）---多态与数组、多重继承、接口的概念
【Java】浅析Java为何抛弃了C++的多继承
本该如此
04-18 1757
当初学C++继承的时候，一开始确实被里面乱七八糟的关系弄的晕得不轻。单继承、多继承、虚继承.....Ծ‸Ծ 当时好像听过一句话：“等你学Java的时候就好了，Java把这些东西都扔了” 罒ω罒//偷笑.jpg 为什么会丢弃这些东西嘞？往下看： #include<iostream> //错误代码 using namespace std; class A{ public:...
java 中抽象类的继承_java抽象类 继承
weixin_42357256的博客
02-23 5348
关于java抽象类 继承的搜索结果回答抽象类和接口的区别：默认的方法实现抽象类可以有默认的方法实现完全是抽象的。接口根本不存在方法的实现。抽象类中可以有已经实现了的方法，也可以有被abstract修饰的方法(抽象方法)，因为存在抽象方法，所以该类必须是抽象类。但是接口要求只能包含抽象方法，抽象方法是指没有实现的方法。所以就不能像抽象类那么无赖了，接口就根本不能存在方法的实现。实现 抽象类使用ex...
C++ 抽象类在多继承中的应用
error0_dameng的博客
09-01 746
 工程中的多继承          被实际开发经验抛弃的多继承；工程开发中真正意义上的多继承是几乎不被使用的；多重继承带来的代码复杂性远多于其带来的便利；多重继承对代码维护性上的影响是灾难性的，在设计方法上，任何多继承都可以单继承代替； 多继承的应用场景           绝大多数面向对象语言都不支持多继承；绝大多数面向对象语言都支持接口的概念；但是C++中没有接口的概念；c++中可以使用...
用接口解决多继承带来的二义性问题
一路向北
02-29 580
工程上的多继承 被实际开发经验抛弃的多继承 工程开发中真正意义上的多继承是几乎不被使用的 多重继承带来的代码复杂性远多于其带来的便利 多重继承对代码维护性上的影响是灾难性的 在设计方法上，任何多继承都可以用单继承代替 多继承中的二义性和多继承不能解决的问题 5.3.2多继承的应用场景 C++中是否有Java中的接口概念？ 绝大多数面向对象语言...
多态的概念和意义
qq_41936794的博客
03-14 529
在之前同名覆盖引发问题的那一篇文章,我们说过了编译器在同名覆盖中所作的行为并不是我们期望的行为,面向对象中期望的行为是根据实际的对象类型判断如何调用重写函数,期望做到父类指针(引用)指向父类对象则调用父类中定义的函数,指向子类对象则调用子类中定义的重写函数,不要根据指针类型去调用,要根据指针指向的对象类型去调用,现在我们引入多态的概念 要实现多态,就需要用到virtual关键字对多态进行支持,被...
类型转化函数
qq_41936794的博客
03-10 505
在我们之前学的C语言中标准数据类型之间会进行隐式类型转化,小类型可以转化到大类型,转化规则如下: 例子: #include <iostream> #include <string> using namespace std; int main() { short s = 'a'; unsigned int ui = 2000; int i = -3000; ...
C/C++异常处理
qq_41936794的博客
03-22 351
异常概念 程序在运行过程中可能产生异常,异常是程序运行时可预料的执行分支,Bug是程序错误,是不可被预期的运行方式 C语言处理异常的方式 void func(...) { if(判断是否产生异常) { 正常情况代码逻辑; } else { 异常情况代码逻辑; } } 例子: #include <iostream> #include <s...
C++前言
qq_41936794的博客
02-25 302
日常生活当中我们都习惯对事物进行分类,C++也就将这种分类的思想引入到程序设计中,将需求中的概念直观的映射到解决方案中,以模块为中心构造可复用的软件系统,提高软件产品的可维护性和可扩展性,面向对象基本概念有类和对象两个概念,类不一定存在实际的对象,类的对象数目是不一定,类之间存在关系的,对象实例不一定属于一个类 类:指的是一类事物,是一个抽象的概念 对象: 指的是属于某个类的具体实体 类是一种模型...
springboot 抛弃feign
最新发布
12-23
这意味着Spring Boot 3不再抛弃Feign，而是提供了一种新的方式来调用远程接口。这种方式可以更加方便和简洁地进行服务调用，同时也提供了更多的功能和扩展性。 以下是一个使用声明式服务调用的示例： ```java // ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值