C++ 继承

于 2023-12-10 21:03:22 发布
阅读量880 收藏 27
点赞数 19
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dabaooooq/article/details/134914093
版权

目录

继承的基本语法

继承方式

公共继承 public

保护继承 protected

私有继承 private 

继承中的对象模型

查看对象模型

继承中构造和析构的顺序

继承同名成员处理方式

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

多继承语法

菱形继承

  

继承的基本语法

继承的用法：

class A : public B;

 A 类称为子类 或 派生类

 B 类称为父类 或 基类

派生类中的成员，包含两大部分：

  1. 一类是从基类继承过来的
  2. 一类是自己增加的成员。

从基类继承过过来的表现其共性，而新增的成员体现了其个性。

#include <iostream>
using namespace std;

//公共页面
class BasePage
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}

	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java,Python,C++...(公共分类列表)" << endl;
	}

};

//Java页面
class Java : public BasePage
{
public:
	void content()
	{
		cout << "JAVA学科视频" << endl;
	}
};
//Python页面
class Python : public BasePage
{
public:
	void content()
	{
		cout << "Python学科视频" << endl;
	}
};
//C++页面
class CPP : public BasePage
{
public:
	void content()
	{
		cout << "C++学科视频" << endl;
	}
};

void test01()
{
	//Java页面
	cout << "Java下载视频页面如下： " << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "--------------------" << endl;

	//Python页面
	cout << "Python下载视频页面如下： " << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "--------------------" << endl;

	//C++页面
	cout << "C++下载视频页面如下： " << endl;
	CPP cp;
	cp.header();
	cp.footer();
	cp.left();
	cp.content();


}

int main() {

	test01();

	return 0;
}

继承方式

  1.     公共继承 public
  2.     保护继承 protected
  3.     私有继承 private

 

公共继承 public


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

//公共继承
class Son1 : public Base1
{
public:
	void func()
	{
		m_A = 1; //可访问 父类中公共成员 到子类中变为 公共成员
		m_B = 2; //可访问 父类中保护成员 到子类中变为 保护成员
		//m_C = 3; 不可访问 父类中私有成员 到子类中变为 私有成员
	}
};

void myClass()
{
	Son1 s1;
	s1.m_A = 10; // 子类只能访问到公共权限
	//s1.m_B; err
}

保护继承 protected

class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son2 :protected Base2
{
public:
	void func()
	{
		m_A = 1; //可访问 父类中公共成员 到子类中变为 保护成员
		m_B = 2; //可访问 父类中保护成员 到子类中变为 保护成员
		//m_C = 3; 不可访问 父类中私有成员 到子类中变为 私有成员
	}
};
void myClass2()
{
	Son2 s;
	//s.m_A; 保护成员类外不可访问
}

私有继承 private 

class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son3 :private Base3
{
public:
	void func()
	{
		m_A = 1; //可访问 父类中公共成员 到子类中变为 私有成员
		m_B = 2; //可访问 父类中保护成员 到子类中变为 私有成员
		//m_C = 3; 不可访问 父类中私有成员 到子类中变为 私有成员
	}
};
//孙子类继承都是私有成员的儿子类
class GrandSon3 :public Son3
{
public:
	void func()
	{
		//Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到
		//m_A;
		//m_B;
		//m_C;
	}
};

继承中的对象模型

查看对象模型

  1. 打开vs 2017的开发人员命令提示符
  2. 跳转盘符 E:
  3. 跳转文件路径 cd 具体路径下 （当前 E:\Administrator\C++\C++\17_继承\3.继承中的对象模型.cpp）
  4.  cl /d1 reportSingleClaassLayout类名 类所属文件名

#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()
{
	/*
		父类中所有非静态成员属性都会被子类继承下去
		父类中私有成员属性 是被编译器给隐藏了，因此是访问不到，但是确实被继承下去了
	*/
	cout << "sizeof Son = " << sizeof(Son) << endl; // 16
}

int main() {

	test01();

	return 0;
}

继承中构造和析构的顺序

继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反

#include <iostream>
using namespace std;

/*
	继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反
*/

class Base
{
public:
	Base()
	{
		cout << "Base构造函数!" << endl;
	}
	~Base()
	{
		cout << "Base析构函数!" << endl;
	}
};

class Son : public Base
{
public:
	Son()
	{
		cout << "Son构造函数!" << endl;
	}
	~Son()
	{
		cout << "Son析构函数!" << endl;
	}

};


void test01()
{
	/*
		Base构造函数!
		Son构造函数!
		Son析构函数!
		Base析构函数!

	*/
	Son s;
}

int main() {

	test01();

	return 0;
}

继承同名成员处理方式

  1. 子类对象可以直接访问到子类中同名成员
  2. 子类对象加作用域可以访问到父类同名成员
  3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数
#include <iostream>
using namespace std;

/*
	1. 子类对象可以直接访问到子类中同名成员
	2. 子类对象加作用域可以访问到父类同名成员
	3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数
*/

class Base {
public:
	Base()
	{
		m_A = 100;
	}

	void func()
	{
		cout << "Base - func()调用" << endl;
	}

	void func(int a)
	{
		cout << "Base - func(int a)调用" << endl;
	}

public:
	int m_A;
};


class Son : public Base {
public:
	Son()
	{
		this->m_A = 200;
	}

	// 当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
	// 如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
	void func()
	{
		cout << "Son - func()调用" << endl;
	}
public:
	int m_A;
};

void test01()
{
	Son s;

	cout << "Son下的m_A = " << s.m_A << endl; // 200
	cout << "Base下的m_A = " << s.Base::m_A << endl; // 100

	s.func(); // Son - func()调用
	s.Base::func(); // Base - func()调用
	//s.func(100); error 子父同名时，就近原则调子，并不会重载
	s.Base::func(10); // Base - func(int a)调用

}
int main() {

	test01();

	return 0;
}

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

静态成员和非静态成员出现同名，处理方式一致

  •     访问子类同名成员   直接访问即可
  •     访问父类同名成员   需要加作用域

同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象 和 通过类名)

#include <iostream>
using namespace std;

class Base {
public:
	static void func()
	{
		cout << "Base - static void func()" << endl;
	}
	static void func(int a)
	{
		cout << "Base - static void func(int a)" << endl;
	}

	static int m_A;
};

int Base::m_A = 100;

class Son : public Base {
public:
	static void func()
	{
		cout << "Son - static void func()" << endl;
	}
	static int m_A;
};

int Son::m_A = 200;

//同名成员属性
void test01()
{
	//通过对象访问
	cout << "通过对象访问： " << endl;
	Son s;
	cout << "Son  下 m_A = " << s.m_A << endl; // 200
	cout << "Base 下 m_A = " << s.Base::m_A << endl; // 100

	//通过类名访问
	cout << "通过类名访问： " << endl;
	cout << "Son  下 m_A = " << Son::m_A << endl; // 200 类似于js中的静态成员访问 Student.staticAttribute
	/* 
	   第一个::代表通过类名方式访问 第二个::代表访问父类作用域下。
	   当前表示 类名方式访问父类作用域下的m_A成员 
	 */
	cout << "Base 下 m_A = " << Son::Base::m_A << endl; // 100
}

// 同名成员函数
void test02()
{
	// 通过对象访问
	cout << "通过对象访问： " << endl;
	Son s;
	s.func(); // Son - static void func()
	s.Base::func(); // Base - static void func()

	// 通过类名访问
	cout << "通过类名访问： " << endl;
	Son::func(); // Son - static void func()
	Son::Base::func(); // Base - static void func()
	//Son::func(100); error 子父同名时，就近原则调子，并不会重载
	// 出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
	Son::Base::func(100); // Base - static void func(int a)
}
int main() {

	test01();
	test02();

	return 0;
}

多继承语法

多继承中如果父类中出现了同名情况，子类使用时候要加作用域

#include <iostream>
using namespace std;

class Base1 {

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

};

class Base2 {
public:
	Base2()
	{
		m_A = 200;  // 开始是m_B 不会出问题，但是改为mA就会出现不明确
	}
public:
	int m_A;
};

// 语法：class 子类：继承方式 父类1 ，继承方式 父类2 
class Son : public Base2, public Base1
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
public:
	int m_C;
	int m_D;
};


// 多继承容易产生成员同名的情况
// 通过使用类名作用域可以区分调用哪一个基类的成员
void test01()
{
	Son s;
	cout << "sizeof Son = " << sizeof(s) << endl; // 16
	cout << s.Base1::m_A << endl; // 100
	cout << s.Base2::m_A << endl; // 200
}

int main() {

	test01();

	return 0;
}

菱形继承

  1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。
  2. 草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。
  • 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
  • 利用虚继承可以解决菱形继承问题
#include <iostream>
using namespace std;

class Animal
{
public:
	int m_Age;
};

// 继承前加 virtual 关键字后，变为虚继承
// 此时公共的父类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 = 100;
	st.Tuo::m_Age = 200;

	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl; // 200 不加vritual，这里是100
	cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl; // 200
	cout << "st.m_Age = " << st.m_Age << endl; // 200 加了vritual后也不会产生二义性报错
}


int main() {

	test01();

	return 0;
}

 

山楂树の
关注
  • 19
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++继承介绍
09-05
C++继承可以是单一继承或多重继承，每一个继承连接可以是public,protected,private也可以是virtual或non-virtual
C++ 继承详解
热门推荐
TABE_的博客
02-21 1万+
C++ 继承继承语法继承方式改变访问权限名字遮蔽继承时的对象模型无变量遮蔽有变量遮蔽 继承语法 继承的一般语法为： class 派生类名:［继承方式］ 基类名{ 派生类新增加的成员 }; 继承方式 继承方式包括 public（公有的）、private（私有的）和 protected（受保护的），此项是可选的，如果不写，那么默认为 private。不同的继承方式会影响基类成员在派生类中的访问权限。 （1）public继承方式 基类中所有 public 成员在派生类中为 public 属性； 基类中
C++继承详解
DR5200的博客
10-14 2456
文章目录一.继承的概念和定义二.基类和派生类对象赋值转换三.继承中的作用域四.派生类的默认成员函数五.继承和友元六.继承与静态成员七.菱形继承及菱形虚拟继承八.C++编译器如何通过虚继承解决数据冗余和二义性 一.继承的概念和定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的
C++继承
彧玊的博客
12-20 1748
C++继承相关的基础知识
C++继承的使用
JayceSun的博客
04-17 1750
定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 ...
详解c++ 继承
08-18
主要介绍了c++ 继承的相关资料，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
C++ 继承详解及实例代码
12-31
C++继承可以是单一继承或多重继承，每一个继承连接可以是public,protected,private也可以是virtual或non-virtual。然后是各个成员函数选项可以是virtual或non-virtual或pure virtual。本文仅仅作出一些关键点的验证...
c++继承分类
04-28
在Qt中编写的c++继承分类的视频
c++继承描述
01-05
c++继承描述
C++继承和派生
01-17
信息科学技术学院《程序设计实习》,C++程序员入门级教程
c++继承的视频
04-28
在Qt中编写的c++继承的视频
实例代码讲解c++ 继承特性
12-17
——派生类需要自己的构造函数。  派生类中可以根据需要添加额外的数据成员和成员函数，甚至可以给予继承的原成员函数新的定义。...　C++11增加了允许继承构造函数的机制，但派生类默认不能继承构造函数和析构
C++ 继承机制易犯的错误
01-21
继承作为面向对象的基本特征之一，其使用率极高。不管是为了实现软件的基本功能，还是再程序的重构的过程中，我们总是会用到继承机制。正是因为其用途极为广泛，而且使用简单，大众程序员对其真正的内部实现机制的...
C++继承与多态性实验报告
03-01
C++继承与多态性实验报告
C++继承介绍及使用方法
10-09
1、本文详细描述了C++语言继承的使用方法。 2、通过详细示例，让读者更直观地阅读，更清晰的理解。 3、示例代码可直接复制，编译后可直接运行。 4、根据示例以及运行结果，让读者加强记忆及理解。
代码讲解C++继承和派生
08-26
在本文中我们通过实例代码给大家讲解下C++继承和派生相关知识点，需要的朋友们学习下。
有关C++继承与友元、继承与类型转换详解
12-31
实例如下： #include <iostream> using namespace std; class a{ friend class pal; private: int i; protected: int j; public: int k; }; class b:public a{ protected: int l; }; class c:protected a{}... }
c++ 继承java类
最新发布
01-12
C++可以继承Java类，但是需要注意一些细节和差异。在C++中，可以使用关键字`class`来定义一个类，并使用关键字`public`来指定继承关系。下面是一个示例： ```cpp class JavaClass { public: void javaMethod() { ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

山楂树の

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值