【C++核心编程 4】——类和对象——4.6 继承

最新推荐文章于 2024-07-24 11:32:27 发布
最新推荐文章于 2024-07-24 11:32:27 发布
阅读量180 收藏
点赞数
分类专栏： C++学习 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/myCSDN3657/article/details/128962146
版权

4.6 继承

继承是面向对象三大特性之一

当下级的成员除了拥有上一级的共性，还有自己的特性，此时利用继承的技术，可以减少重复代码


4.6.1 继承的基本语法

语法：class子类:继承方式 父类

#include<iostream>
using namespace std;
//继承实现页面
class BasePage {
public:
	void header() {
		cout << "首页" << endl;
	}
	void footer() {
		cout << "帮助中心" << endl;
	}
	void left() {
		cout << "Java、Python、C++..." << endl;
	}
};
class Java :public BasePage{
public:
	
	void content() {
		cout << "Java学科视频" << endl;
	}
};
class Python :public BasePage {
public:

	void content() {
		cout << "Python学科视频" << endl;
	}
};
class CPP :public BasePage {
public:

	void content() {
		cout << "CPP学科视频" << endl;
	}
};
void test01() {
	cout << "Java页面如下：" << endl;
	Java j;
	j.header();
	j.left();
	j.content();
	j.footer();
	cout << "Python页面如下：" << endl;
	Python p;
	p.header();
	p.left();
	p.content();
	p.footer();
	cout << "CPP页面如下：" << endl;
	CPP c;
	c.header();
	c.left();
	c.content();
	c.footer();
}
int main() {
	test01();
	return 0;
}

子类中的成员：

  • 从父类继承过来的，表现其共性
  • 自己增加的成员，表现其个性


4.6.2 继承方式

继承的语法：class 子类:继承方式 父类

继承方式一共有三种：

  • 公共继承
  • 保护继承
  • 私有继承

在这里插入图片描述

#include<iostream>
using namespace std;
class Base1 {
public:
	int a;
protected:
	int b;
private:
	int c;
};
class Son1 : public Base1 {
public:
	void func() {
		a = 10;//父类中的公共权限成员，到子类中依然是公共权限
		b = 20;//父类中的保护权限成员，到子类中依然是保护权限
		//c = 30;父类中的私有权限成员，子类不可访问
	}
};
class Son2 : protected Base1 {
public:
	void func() {
		a = 10;//父类中的公共权限成员，到子类中变为保护权限
		b = 20;//父类中的保护权限成员，到子类中依然是保护权限
		//c = 30;父类中的私有权限成员，子类不可访问
	}
};
class Son3 : private Base1 {
public:
	void func() {
		a = 10;//父类中的公共权限成员，到子类中变为私有权限
		b = 20;//父类中的保护权限成员，到子类中变为私有权限
		//c = 30;父类中的私有权限成员，子类不可访问
	}
};
class GrandSon3 : public Son3 {
public:
	void func() {
		//a = 10;//Son3类中变为了私有权限成员，子类不可访问
		//b = 20;//Son3类中变为了私有权限成员，子类不可访问
		//c = 30;Son3类中变为了私有权限成员，子类不可访问
	}
};
void test01() {
	Son1 s1;
	s1.a = 100;
	//s1.b = 200;在Son1 中 b是保护权限，类外访问不到
	
	Son2 s2;
	//s2.a = 100;在Son2 中 a是保护权限，类外访问不到
	//s2.b = 200;在Son2 中 b是保护权限，类外访问不到
	
	Son3 s3;
	//s3.a = 100;//在Son2 中 a是私有权限，类外访问不到
	//s3.b = 200;在Son2 中 b是私有权限，类外访问不到
}
int main() {
	test01();
	return 0;
}


4.6.3 继承中的对象模型

问题：从父类继承过来的成员，哪些属于子类对象中？

父类中所有非静态成员属性都会被子类继承下去

#include<iostream>
using namespace std;
class Base1 {
public:
	int a;
protected:
	int b;
private:
	int c;
};
class Son : public Base1 {
public:
	int d;
};

void test01() {
	//父类中所有非静态成员属性都会被子类继承下去
	cout << "size of Son =" << sizeof(Son) << endl;//16,一共4个成员

	//父类中私有成员属性 是被编译器隐藏了，因此访问不到，但被子类继承下去了
}
int main() {
	test01();
	return 0;
}

4.6.4 继承中构造和析构顺序

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

问题：父类和子类的构造和析构顺序是谁先谁后？


继承中的构造和析构顺序：
构造：先构造父类，再构造子类
析构：先析构子类，再析构父类

#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() {
	Son s1;
}
int main() {
	test01();
	return 0;
}


4.6.5 继承同名成员处理方式

  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域
#include<iostream>
using namespace std;
class Base {
public:
	Base() {
		a = 100;
	}
	void func() {
		cout << "Base-func" << endl;
	}
	int a;
};
class Son : public Base {
public:
	Son() {
		a = 200;
	}
	void func() {
		cout << "Son-func" << endl;
	}
	int a;
};

void test01() {
	Son s1;
	//同名变量调用
	cout << "Son   s1.a=" << s1.a << endl;//200
	cout << "Base  s1.a=" << s1.Base::a << endl;//100
	//同名成员函数调用
	cout << "Son   s1.func()="  << endl;
	s1.func();
	cout << "Base  s1.func()="  << endl;
	s1.Base::func();
}
int main() {
	test01();
	return 0;
}

1.子类对象可直接访问到子类中同名成员

2.子类对象加作用域可以访问到父类同名成员

3.如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数（包括重写的），若想访问，则需加作用域


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

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

  • 访问子类同名成员，直接访问即可
  • 访问父类同名成员，需要加作用域
#include<iostream>
using namespace std;
//继承中的同名静态成员处理方式
class Base {
public:
	static int m_a;
	static void func() {
		cout << "Base void func()" << endl;
	}
	static void func(int a) {
		cout << "Base void func(int "<<a<<")" << endl;
	}

};
int Base::m_a = 100;
class Son:public Base {
public:
	static int m_a;
	static void func() {
		cout << "Son void func()" << endl;
	}
};
int Son::m_a = 200;

//同名静态成员变量
void test01() {
	//1.通过对象来访问
	Son s;
	cout << "Son m_a=" << s.m_a << endl;
	cout << "Base m_a=" << s.Base::m_a << endl;
	//2.通过类名来访问
	cout << "Son m_a=" << Son::m_a << endl;
	cout << "Base m_a=" << Son::Base::m_a << endl;
	//第一个::代表通过类名方式来访问，第二个::代表访问父类作用域下
}
//同名静态成员函数
void test02() {
	//1.通过对象来访问
	Son s;
	s.func();
	s.Base::func();

	//2.通过类名来访问
	Son::func();
	Son::Base::func();

	//子类出现和父类同名静态成员函数，也会隐藏父类中所有同名成员函数
	//如果像访问父类中被隐藏同名成员函数，需要加作用域
	Son::Base::func(100);
}
int main() {
	//test01();
	test02();
	return 0;
}

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


4.6.7 多继承语法

C++允许一个类继承多个类

语法：class 子类:继承方式 父类1,继承方式 父类2,...

示例：

#include<iostream>
using namespace std;

//多继承语法
class Base1 {
public:
	Base1() {
		m_a = 100;
	}
	int m_a;
};
class Base2 {
public:
	Base2() {
		m_b = 200;
	}
	int m_b;
};
class Son :public Base1, public Base2 {
public:
	Son() {
		m_c = 300;
		m_d = 400;
	}
	int m_c;
	int m_d;
};
void test01() {
	Son s;
	cout << "sizeof Son=" << sizeof(s) << endl;//16，共有4个成员
}
int main() {
	test01();
	return 0;
}

在这里插入图片描述

多继承中可能会引发父类中有同名成员出现，需要加作用域区分
在这里插入图片描述

#include<iostream>
using namespace std;

//多继承语法
class Base1 {
public:
	Base1() {
		m_a = 100;
	}
	int m_a;
};
class Base2 {
public:
	Base2() {
		m_a = 200;
	}
	int m_a;
};
class Son :public Base1, public Base2 {
public:
	Son() {
		m_c = 300;
		m_d = 400;
	}
	int m_c;
	int m_d;
};
void test01() {
	Son s;
	//当父类中出现同名成员，需要加作用域区分
	cout << "Base1中的m_a" << s.Base1::m_a << endl;
	cout << "Base2中的m_a" << s.Base2::m_a << endl;

}
int main() {
	test01();
	return 0;
}

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


4.6.8 菱形继承

概念：

​ 两个子类继承同一个父类

​ 又有某个类同时继承这两个派生类

​ 这种继承方式被称为菱形继承，或者钻石继承
在这里插入图片描述

菱形继承问题：

  1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性
  2. 草泥马继承自动物的数据继承了两份，导致资源浪费，有的数据只需要一份就可以

利用虚继承，解决菱形继承的问题

继承之前，加上关键字virtual变为虚继承

#include<iostream>
using namespace std;
//动物类
class Animal {
public:
	int m_age;
};

//利用虚继承，解决菱形继承问题 
// 继承之前，加上关键字virtual变为 虚继承
// 此时Animal类 称为 虚基类
//羊类
class Sheep:virtual public Animal {

};
//驼类
class Camel :virtual public Animal {

};
//羊驼
class Vicuna:public Sheep,public Camel{

};
void test01() {
	Vicuna v;
	//v.m_age = 10;指向不明确
	v.Sheep::m_age = 10;
	v.Camel::m_age = 12;

	//当出现菱形继承时，相当于两个父类拥有相同数据，需要加以作用域区分
	cout << "v.Sheep::m_age" << v.Sheep::m_age << endl;
	cout << "v.Camel::m_age" << v.Camel::m_age << endl;
	//这份数据只需要一份，但菱形继承导致数据有两份，浪费资源
    //通过虚继承解决这个问题
    cout << " v.m_age" << v.m_age << endl;
}
int main() {
	test01();
	return 0;
}

并不是继承了两个数据，而是继承了两个指针，通过偏移量找到唯一的数据
在这里插入图片描述

mycsdn3657
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《由浅入深学C++-基础、进阶与必做300题》pdf格式 （完整版 带目录
07-26
本书循序渐进地讲述了C++的基础知识、C++程序的组成及其开发过程、C++程序中的数据、表达式和语句、控制程序流程、数组与字符串、指针与引用、使用函数、函数模板、错误和异常处理、宏和预编译、面向对象的开发、...
c++课程设计资料···········
08-25
- 理解和掌握C++的关键特性，如类、对象、继承、多态、虚函数、模板和流类库。 - 实践软件开发的完整流程，包括分析、设计、实现、集成和测试，以及编写相关文档。 - 熟练使用Visual C++这样的开发工具，特别是基于...
《C++语言基础》程序阅读——继承和派生
weixin_34122548的博客
05-12 189
返回：贺老师课程教学链接 （1） #include <iostream> using namespace std; class Data { public: Data(int i):x(i) { cout<<"A"; } ~Data() { cout&l...
第十二周项目1.1长颈鹿类对动物类的继承（public继承方式下）
u012317188的专栏
05-13 597
/* *程序的版权和版本声明部分： *Copyright(c)2014，烟台大学计算机学院学生 *All rights reserved. *文件名称:长颈鹿类对动物类的继承 *作者：孙玲倩 *完成日期：2014 年 5 月 13 日 *版本号：v1.0 *对任务及求解方法的描述部分： *输入描述：无 *问题描述：在下面的程序中要求的位置写下注释，声明相应的语句在语法上是否正
浅析c++ public protected private的访问控制
zhaowenchaofang的专栏
04-30 807
个人体会：继承并不是基类的东西全是你的，当出现多次间接继承的时候，这个问题就凸显出来了 c++中private,public,protected的访问控制 第一:private,public,protected方法的访问范围.（public继承下） private: 只能由该类中的函数、其友元函数访问,不能被任何其他访问，该类的对象也不能访问. protected: 可以被该类中的
C++类的特性之继承
简简简简abc
10-10 488
继承：首先从一段代码开始：#include <iostream> using namespace std;//动物 class animal{ public: void eat(){ cout<<"eat"<<endl; } void sleep(){ cout << "sleep" << endl; } void breath()
C++每日学习笔记DAY6
m0_49025316的博客
07-11 185
一步一步学习，坚持见真章
C++核心编程——4 类和对象- 4.6 继承
crisp077的博客
06-06 120
​ 继承是面向对象三大特性之一​ 有些类与类之间存在特殊关系，定义某些类时，下级别的成员除了拥有上一级的共性，还有自己的特性​ 这个时候我们就可以考虑利用继承的技术，减少重复代码​ 语法：​ 例如我们看到很多网站中，都有公共的头部，公共的的底部，甚至公共的左侧列表，只有中心内容不同​ 接下来我们分别利用普通写法和继承写法来实现网页中的内容，看一下继承存在的意义以及好处 ​ 派生类中的成员包含两大部分：​ 一类是从基类继承过来的，一类是自己增加的成员​ 从基类继承过来的表现其共性，而新增的成员体现了其个性​
黑马程序员：C++核心编程——4.类和对象
chenjialehhh的博客
03-24 1081
封装、继承、多态class和struct的唯一区别：默认访问权限不同。class默认是private，struct默认是public。
C++核心编程——4.6 继承
2301_81926399的博客
04-29 1345
介绍C++核心编程第四篇第六章，主要包括C++三大特征之一的继承，继承的概念定义、继承方式、对象模型、构造析构顺序、同名（静态）成员函数的处理方法，多态继承以及菱形继承等的C++核心知识和内容
C++核心编程——4 类和对象
谢谢你们的关注
07-05 177
C++核心编程——4 类和对象
你必须知道的495个C语言问题.pdf
01-20
2.5 在C语言中是否有模拟继承等面向对象程序设计特性的好方法？ 2.6 为什么声明extern f(struct x *p); 给我报了一个晦涩难懂的警告信息？ 2.7 我遇到这样声明结构的代码：struct name {int namelen; char namestr[1...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1175
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
VS2019编译和使用gtest测试（C++）
最新发布
m0_65635427的博客
07-24 259
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1121
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
C++ | Leetcode C++题解之第275题H指数II
Ddddddd_158的博客
07-23 361
C++ | Leetcode C++题解之第275题H指数II
C++实验：面向对象程序设计——类与对象的应用
“实验一 C++类和对象的应用.doc”是一个面向广州大学学生的C++实验报告，旨在通过实际操作加深学生对C++类和对象的理解，包括类的封装、构造函数、析构函数、函数重载以及默认参数函数的运用。实验使用了Visual ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值