19、C++继承-（对象模型，子父类同名成员，菱形继承）

最新推荐文章于 2022-08-12 17:58:09 发布
最新推荐文章于 2022-08-12 17:58:09 发布
阅读量159 收藏
点赞数
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48716770/article/details/119862031
版权

一、继承的基本语法

基类（父类）

派生类（子类）

继承：减少重复代码

class 子类 ：public 父类

{

}

二、继承方式

基类：public权限、protected权限、private权限

1、公共继承（除私有，其他权限和父类一模一样）

共有继承：基类public权限(任然在派生类public)、

                  基类protected权限(任然在派生类protected)、

                  基类private(不可访问)

2、保护继承（除私有，其他全部变为保护）

保护继承：基类public权限(在派生类protected)、

                  基类protected权限(任然在派生类protected)、

                  基类private(不可访问)

3、私有继承（除私有，其他全部变为私有）

私有继承：基类public权限(在派生类private)、

                  基类protected权限(在派生类private)、

                  基类private(不可访问)

父类的私有权限内容，派生类均不可访问

#include<iostream>
using namespace std;

class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

//1、公共继承
class Son1 :public Base
{
public:
	void func()
	{
		m_A = 10;    //共有
		m_B = 10;    //保护
		//m_C = 10;	×
	}
};

void test01()
{
	Son1 s1;
	s1.m_A = 10;
	//s1.m_B = 10;	×
}

//2、保护继承
class Son2 :protected Base
{
public:
	void func()
	{ 
		m_A = 10;    //保护
		m_B = 10;    //保护
		//m_C = 10;   ×
	}
};

void test02()
{
	Son2 s2;
	//s2.m_A = 10;  ×
	//s2.m_B = 10;
}

//3、私有继承
class Son3 :private Base
{
	void func()
	{
		m_A = 10;    //私有
		m_B = 10;    //私有
		//m_C = 10;	×
	}
};

class GrandSon3 :public Son3
{
	void func()
	{
		//m_A = 10;	×
		//m_B = 10;	×
	}
};

void test03()
{
	Son3 s3;
	//s3.m_A = 10;	×
}

int main()
{


	system("pause");
	return 0;
}

三、继承中的对象模型

父类中非静态成员都会被子类继承下去
父类中私有成员属性，是被编译器隐藏了，所有访问不了，但是确实被继承给了子类

class Base
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
};

class Son :public Base
{
public:
    int m_D;
};
Son s1;
//父类中私有成员属性，是被编译器隐藏了，所有访问不了，但是确实被继承给了子类
cout << sizeof(s1) << endl;     //sizeof(s1)=16

#include<iostream>
using namespace std;

class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

class Son :public Base
{
public:
	int m_D;
};

void test01()
{
	Son s1;
	//父类中非静态成员都会被子类继承下去
	//父类中私有成员属性，是被编译器隐藏了，所有访问不了，但是确实被继承给了子类
	cout << sizeof(s1) << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

四、继承中构造和析构顺序

子类继承父类后，创建子类的对象时，也会调用父类的构造函数

父类和子类构造，析构调用顺序：

先构造父类，再构造子类。析构顺序刚好相反。

——————————————

class Base
{
public:
    Base()
    {
        cout << "调用基类构造函数" << endl;
    }
    ~Base()
    {
        cout << "调用基类~析构函数" << endl;
    }
};

class Son:public Base
{
public:
    Son()
    {
        cout << "调用--子类构造函数" << endl;
    }
    ~Son()
    {
        cout << "调用--子类~析构函数" << endl;
    }
};

————————————————

五、继承同名成员处理方式

子类与父类出现同名成员，通过子类对象，访问子类或父类中同名数据

访问子类同名成员：直接访问

访问父类同名成员：加作用域访问

(1)、如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类的所有同名成员.此时想访问父类要加作用域

Son s;
cout << s.m_A << endl;
cout << s.Base::m_A << endl;

s.func()；
s.Base::func(100);

(2)、如果子类没有，父类有，则可直接访问

s.Base::func(100);
可简化为：s.func(100); --->子类访问父类中的成员函数

如果子类有func(),父类有func(int)重载的，不可直接访问

#include<iostream>
using namespace std;

class Base
{
public:
	Base()
	{
		m_A = 100;
	}
	//void func()
	//{
	//	cout << "Base" << endl;
	//}
	void func(int)
	{
		cout << "Base func(int)" << endl;
	}
public:
	int m_A;
};

class Son :public Base
{
public:
	Son()
	{
		m_A = 200;
	}
	//void func()
	//{
	//	cout << "Son ." << endl;
	//
public:
	int m_A;
};

//同名成员变量
void test01()
{
	Son s;
	cout << s.m_A << endl;
	cout << s.Base::m_A << endl;
}

//同名成员函数
void test02()
{
	Son s;
	//s.func();

	//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类的所有同名成员
	//想访问父类要加作用域
	s.Base::func(100);
	s.func(100);
}

int main()
{
	//test01();
	test02();

	system("pause");
	return 0;
}

六、继承同名静态成员处理方式

继承同名静态成员处理 与 继承同名成员相同

(1)、访问静态成员变量

Son s;
1、通过对象访问静态成员变量
    cout << s.m_A << endl;                //子类
    cout << s.Base::m_A << endl;     //通过子类访问父类
    
2、通过类名访问静态成员变量
   cout << Son::m_A << endl;                //子类
    cout << Son::Base::m_A << endl;     //通过子类访问父类
    cout << Base::m_A << endl;             //父类

(Base::m_A  和  Son::Base::m_A 一样）

(2)、访问静态成员函数

Son s;
1、通过对象访问静态成员函数
    s.func();                  //子类
    s.Base::func();       //通过子类访问父类

2、通过类名访问静态成员函数
    Son::func();                  //子类
    Son::Base::func();       //通过子类访问父类
    Base::func();                //父类

如果子类有func(),父类有func(int)重载的，不可直接访问

七、多继承语法

当父类中有同名成员出现时，必须加作用域才能区分。

c++实际开发不建议使用多继承

class Base1
{
public:
    Base1()
    {
        m_A = 100;
    }
public:
    int m_A;
};

class Base2
{
public:
    Base2()
    {
        m_A = 100;
    }
public:
    int m_A;
};

class Son :public Base1, public Base2
{
public:
    Son()
    {
        m_C = 300;
        m_D = 400;
    }
public:
    int m_C;
    int m_D;
};
    Son s;
    cout << "sizeof(s)=" << sizeof(s) << endl;    // 16
    cout << "sizeof(Son)=" << sizeof(Son) << endl;      //16  

    //父类中出现同名成员时，要加作用域才能区分
    cout << "Base1 m_A=" << s.Base1::m_A << endl;
    cout << "Base2 m_A=" << s.Base2::m_A << endl;

八、菱形继承

1、菱形继承

class A

class B:public A

class C:public A

class D:public B,public C

——————————————————————

class Animal
{
public:
    int m_Age;
};
class Sheep :public Animal { };

class Tuo :public Animal { };

class SheepTuo :public Sheep, public Tuo { };

---------------------------------------------

    SheepTuo st;
    st.Sheep::m_Age = 10;
    st.Tuo::m_Age = 7;

    //菱形继承，父类拥有相同数据，必须加作用域才能区分
    cout << "st.Sheep::m_Age =" << st.Sheep::m_Age << endl;    //10
    cout << "st.Tuo::m_Age =" << st.Tuo::m_Age << endl;             //7

     cout << st.m_Age << endl;    //×，二义性

问题：那么此时，SheepTuo的m_Age 为10 还是 7 ？

解决：（使用虚继承）

————————————————————

2、引发问题

1、B继承A数据，C继承A数据，当D使用数据时，会产生二义性

2、D的数据继承了两份，数据重复了

——————————————————————

class Animal
{
public:
    int m_Age;
};

//采用虚继承，此时Animal为虚基类
class Sheep :virtual public Animal { };

class Tuo :virtual public Animal { };

class SheepTuo :public Sheep, public Tuo { };

---------------------------------------------

    SheepTuo st;
    st.Sheep::m_Age = 10;
    st.Tuo::m_Age = 7;

    //菱形继承，父类拥有相同数据，必须加作用域才能区分
    cout << "st.Sheep::m_Age =" << st.Sheep::m_Age << endl;    //7
    cout << "st.Tuo::m_Age =" << st.Tuo::m_Age << endl;             //7

     cout << st.m_Age << endl;  //√，不会再报错

使用虚继承，Sheep和Tuo共享一份数据，

所以 st.Tuo::m_Age = 7;相当于把共享的再次都修改为7

——————————————————————

未使用虚继承时

 使用虚继承时，vbptr 虚基类指针

Sheep 和 Tuo 保存的是 vbptr

 

#include<iostream>
using namespace std;

class Animal
{
public:
	int m_Age;
};

//虚继承,Animal为虚基类
class Sheep :virtual public Animal { };

class Tuo :virtual public Animal { };

class SheepTuo :public Sheep, public Tuo { };

void test01()
{
	SheepTuo st;
	st.Sheep::m_Age = 10;
	st.Tuo::m_Age = 7;

	//菱形继承，父类拥有相同数据，必须加作用域才能区分
	cout << "st.Sheep::m_Age =" << st.Sheep::m_Age << endl;
	cout << "st.Tuo::m_Age =" << st.Tuo::m_Age << endl;

	//菱形继承有两份数据，浪费资源
	//使用虚继承，Sheep和Tuo共享一份数据
	cout << st.m_Age << endl;

}

int main()
{
	test01();

	system("pause");
	return 0;
}

菱形继承值问题

    A a;
    a.m_A = 10;

    B b;
    b.m_A = 20;

    C c;
    c.m_A = 30;

    D d;

    d.B::m_A = 200;
    d.C::m_A = 300;

    cout << d.m_A << endl;   //300
    cout << a.m_A << endl;     //10
    cout << b.m_A << endl;     //20
    cout << c.m_A << endl;   //30

#include<iostream>
using namespace std;

class A
{
public:
	int m_A;
};

class B :virtual public A { };

class C :virtual public A { };

class D :public B,public C { };


void test01()
{
	A a;
	a.m_A = 10;

	B b;
	b.m_A = 20;

	C c;
	c.m_A = 30;

	D d;

	d.B::m_A = 200;
	d.C::m_A = 300;

	cout << d.m_A << endl;   //300
	cout << a.m_A << endl;	 //10
	cout << b.m_A << endl;	 //20
	cout << c.m_A << endl;   //30
}

int main()
{
	test01();

	system("pause");
	return 0;
}

bajieke
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++类继承之子类调用父类的构造函数的实例详解
08-29
主要介绍了C++类继承之子类调用父类的构造函数的实例详解的相关资料,希望通过本文大家能够掌握C++类继承的相关知识，需要的朋友可以参考下
【C++】继承（菱形继承）
zhangyi_ZY的博客
04-03 601
面向对象编程 一.继承 在面向对象编程中，继承是当对象或类基于另一个对象（原型继承）或类（基于类的继承）时，使用相同的实现（从对象或类继承）或指定新的实现来维护相同的行为。这样的继承类被称为其父类或超类的子类。它是代码重用的一种机制，允许通过公共类和接口独立扩展原始软件。 继承是类型之间的关系建模，共享公有的东西，实现各自的本质。 1.继承的三种关系 （1）公有继承（public）：
C++继承（多继承、菱形继承？）
lirendada的博客
08-12 809
派生类 继承方式 基类👇 👇 👇public:// 学号};我们以上面为例子，People是父类，也称为基类。而Student叫做子类，也成为派生类。🔴注意：若不写继承方式，默认就是 private 继承！很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java。......
C++的重大特性之一：继承、菱形继承
qq_56870066的博客
06-30 859
继承
c++对象模型（继承，虚拟继承，菱形继承）
fl_sw的博客
08-14 476
谈及c++对象模型，内容还是比较繁复，为了便于理解，我将循序渐进的按照以下步骤说明： 1.对象模型是什么？ 2.具体继承下的对象模型。 3.对象模型与内存对齐 4.多重继承 5.菱形继承 6.虚拟继承 1.对象模型是什么？ 一般的，C++中类的对象模型是这样的： 非静态的成员变量被配置于对象中，排列顺序和声明顺序一致 静态的成员变量则被存储在对象之外；存储在全局的数据段中，永远...
在C++中子类继承和调用父类的构造函数方法
01-21
因此，在创建子类对象时，为了初始化从父类继承来的数据成员，系统需要调用其父类的构造方法。 　如果没有显式的构造函数，编译器会给一个默认的构造函数，并且该默认的构造函数仅仅在没有显式地声明构造函数情况下...
C++ 多重继承和虚拟继承对象模型、效率分析
01-01
通过带有虚函数的单一继承我们可以清楚的理解继承的概念、对象模型的分布机制以及动态绑定的发生，即可以完全彻底地理解多态的思想。为了支持多态，语言实现必须在时间和空间上付出额外的代价（毕竟没有免费的晚餐，...
C++程序设计 继承------继承方式 继承中构造函数析构函数的顺序 继承同名成员处理方式 继承静态同名成员处理方式 菱形继承(virtual)
weixin_44176501的博客
04-21 177
继承 前言 <1>继承是面向对象的三大特性之一 <2>有些类与类之间存在特殊的关系，我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还拥有自己的特性。这个时候我们就可以考虑利用继承的技术. <3>继承的好处就是减少重复代码 <4>语法: class 子类 : 继承方式 父类 <5>子类有时候也称为派生类 父类有时候也被称为基类 一、继承方式 继承语法: class 派生类:继承方式 父类 1.公有继承 在公有继承的时候，基类的私有成员是不
c++虚继承|菱形继承(也是继承的同名问题)-----virtual修饰的继承方式
weixin_60569662的博客
12-02 345
虚继承---满足菱关系才有虚继承 引入虚继承： A类中有一个a属性，A继承产生B类也有一个属性a，A继承产生C类也有一个属性a，B、C类继承产生D类--->普通的继承方式让D类中有两个属性a，有两个拷贝本，a由谁决定？ 解决方案： 让相同的a属性只保留一份(让两个a只有一个有效)--->用虚继承--->这份a必须让A的构造函数初始化(在D类中调用A类（祖先类）的构造函数) 用虚继承的方式 class B :virtual public A { }; 用virt.
C++虚拟多重继承对象模型讨论-样例
03-26
仅仅是一个讨论使用的样例程序，详细内容参考：http://blog.csdn.net/magictong/article/details/22202393
C++继承的对象模型
qq_56615615的博客
12-13 353
查看C++继承对象在内存中所占的的字节： 代码段： #define _CRT_SECURE_NO_WARNINGS 1 #include <iostream> using namespace std; class Base { public: int A{}; protected: int B{}; private: int C{}; }; class Son : public Base { public: int D; protected: private: }; int ma
图说C++对象模型：对象内存布局详解
weixin_34272308的博客
10-25 1179
0.前言 文章较长，而且内容相对来说比较枯燥，希望对C++对象的内存布局、虚表指针、虚基类指针等有深入了解的朋友可以慢慢看。 本文的结论都在VS2013上得到验证。不同的编译器在内存布局的细节上可能有所不同。 文章如果有解释不清、解释不通或疏漏的地方，恳请指出。 1.何为C++对象模型? 引用《深度探索C++对象模型》这本书中的话： 有两个概念可以解释C++对象模型： 语言中直接支持面向对象程...
C++学习之继承中的对象模型
阿乐的博客
09-25 64
问题：从父类继承过来的成员，哪些属于子类对象中？ 所有成员都属于子类对象，私有成员只是被隐藏了，但是还是会继承下去 #include<iostream> #include<string> using namespace std; class base//父类 { public: int a; protected: int b; private: int c; }; /*公有继承*/ class son1:public base { public: in
探索c++对象模型
weixin_33747129的博客
03-21 98
c++中多态的实现我们都知道，c++中的多态是在虚函数的基础上实现的，用指向派生类的基类指针调用派生类（或基类）中自己的成员函数。那么，具体是怎么实现的呢？其实它是通过虚函数表来实现的，虚函数表是保存虚函数地址的一张表，若一个类中有虚函数，当程序运行时，编译器通过在虚函数表中查找相应的虚函数的地址来调用该函数。对象的继承有如下几类：1.单一继承2.多重继承3.重复继承（钻石...
C++继承时的对象模型
chengonghao的博客
04-05 2009
点击打开链接 在没有继承时对象的内存模型很简单，成员变量和成员函数会分开存储： 对象的内存中只包含成员变量，存储在栈区或堆区（使用 new 创建对象）；成员函数与对象内存分离，存储在代码区。 当存在继承关系时，内存模型会稍微复杂一些。 继承时的内存模型 有继承关系时，派生类的内存模型可以看成是基类成员变量和新增成员变量的总和，所有成员函数仍在另外一个区域——代码区，由
C++对象模型之简述C++对象的内存布局
热门推荐
ljianhui的专栏
05-22 1万+
在C++中，有两种类的成员变量：static和非static，有三种成员函数：static、非static和virtual。那么，它们如何影响C++的对象在内存中的分布呢？ 当存在继承的情况下，其内存分布又是如何呢？ 下面就一个非常简单的类，通过逐渐向其中加入各种成员，来逐一分析上述两种成员变量及三种成员函数对类的对象的内存分布的影响。 注：以下的代码的测试结果均是基于Ubuntu 14.0
深度探索C++对象模型之一 --- 关于对象
Aaron的专栏
05-11 814
深度探索C++对象模型之一 — 关于对象
C++继承中的对象模型
zuoyiyi的博客
11-18 182
继承中的对象模型 父类中所有非静态成员属性都会被子类继承下去 实例如下 #include<iostream>//标准输入/输出流对象头文件 using namespace std;//使用C++标准程序库的标识符声明 class Dad//定义一个父类 { public: int m_A;//父类下的共有属性 protected: int m_B;//父类下的保护属性 private: int m_C;//父类下的私有属性 }; class Son : public Dad//定义一个子类
c++:子类对象转化为父类对象
最新发布
06-07
在向上转型后，父类对象只能访问子类对象中继承自父类的成员，而不能访问子类对象中特有的成员。 例如，假设有一个 Animal 类和一个 Dog 类继承自 Animal 类，可以将一个 Dog 对象转换为 Animal 对象，代码如下所示...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值