当前位置： 首页 > news >正文

《C++继承详解：从入门到理解公有、私有与保护继承》

news 2025/7/29 11:53:31

《C++继承详解：从入门到理解公有、私有与保护继承》

文章目录

  • 《C++继承详解：从入门到理解公有、私有与保护继承》
  • 一、继承的概念及定义
    • 1.1 继承的概念
    • 1.2 继承定义
      • 1.2.1 定义格式
      • 1.2.2 继承基类成员访问方式的变化
    • 1.3 继承类模版
  • 二、基类和派生类间的转换
  • 三、继承中的作用域
    • 3.1 隐藏规则
    • 3.2 考察继承作用域相关选择题
  • 四、派生类的默认成员函数
    • 4.1 4个常见的默认成员函数
    • 4.2 实现一个不能被继承的类
  • 五、继承与友元
  • 六、继承与静态成员
  • 七、多继承及其菱形继承问题
    • 7.1 继承模型
    • 7.2 虚继承
    • 7.3 IO库中的菱形虚拟继承
  • 八、继承和组合
  • 九、整体源代码

一、继承的概念及定义

1.1 继承的概念

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述在这里插入图片描述

1.2 继承定义

1.2.1 定义格式

在这里插入图片描述在这里插入图片描述

1.2.2 继承基类成员访问方式的变化

在这里插入图片描述

在这里插入图片描述

1.3 继承类模版

继承类模版就是继承一个模版类，大框架和普通的继承想吐，但是调用父类中的属性或者行为时要指定在父类的哪个属性或者行为，这样是因为类模版的按需实例化，不指定就不会实例化，会报错
下面是用继承写一个栈，这个栈继承了父类vector
每次复用vector里面的成员函数时都要指定父类类域，否则报错，找不到标识符

在这里插入图片描述
在这里插入图片描述

二、基类和派生类间的转换

在这里插入图片描述在这里插入图片描述
在这里插入图片描述

三、继承中的作用域

3.1 隐藏规则

在这里插入图片描述在这里插入图片描述

3.2 考察继承作用域相关选择题

在这里插入图片描述

四、派生类的默认成员函数

4.1 4个常见的默认成员函数

在这里插入图片描述在这里插入图片描述

在这里插入图片描述

4.2 实现一个不能被继承的类

在这里插入图片描述

在这里插入图片描述

五、继承与友元

友元关系不能继承，也就是说基类友元不能访问派生类私有和保护成员
在这里插入图片描述

六、继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个派生类，都只有一个static成员实例
在这里插入图片描述

七、多继承及其菱形继承问题

7.1 继承模型

在这里插入图片描述

单继承和多继承
在这里插入图片描述

菱形继承： 会出现 二义性 和 数据冗余 的问题
在这里插入图片描述

在这里插入图片描述

7.2 虚继承

为了解决菱形继承的两个问题，这里使用虚继承，也就是在开始继承相同的基类的派生类后面加上virtual再加继承方式和基类
在这里插入图片描述在这里插入图片描述

我们可以设计出多继承，但是不建议设计出菱形继承，因为菱形虚拟继承以后，无论是使用还是底层都会复杂很多。当然有多继承语法支持，就一定存在会设计出菱形继承，像Java是不支持多继承的，就避开了菱形继承
在这里插入图片描述
在这里插入图片描述

7.3 IO库中的菱形虚拟继承

在这里插入图片描述

八、继承和组合

在这里插入图片描述

在这里插入图片描述

九、整体源代码

代码如下（示例）：

#include<iostream>
using namespace std;//class Student
//{
//public:
//	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
//	void identity()
//	{
//		// ...
//	}
//	// 学习
//	void study()
//	{
//		// ...
//	}
//protected:
//	string _name = "peter"; // 姓名
//	string _address; // 地址
//	string _tel; // 电话
//	int _age = 18; // 年龄
//	int _stuid; // 学号
//};
//class Teacher
//{
//public:
//	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
//	void identity()
//	{
//		// ...
//	}
//	// 授课
//	void teaching()
//	{
//		//...
//	}
//protected:
//	string _name = "张三"; // 姓名
//	int _age = 18; // 年龄
//	string _address; // 地址
//	string _tel; // 电话
//	string _title; // 职称
//};
//int main()
//{
//	return 0;
//}//class Person
//{
//public:
//	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
//	void identity()
//	{
//		cout << "void identity()" << _name << endl;
//	}
//protected:
//	string _name = "张三";  // 姓名
//	string _address;       // 地址
//	string _tel;           // 电话
//	int _age = 18;         // 年龄
//};
//class Student : public Person
//{
//public:
//	// 学习
//	void study()
//	{
//		// ...
//	}
//protected:
//	int _stuid; // 学号
//};
//class Teacher : public Person
//{
//public:
//	// 授课
//	void teaching()
//	{
//		//...
//	}
//protected:
//	string title; // 职称
//};
//int main()
//{
//	Student s;
//	Teacher t;
//	s.identity();
//	t.identity();
//	return 0;
//}// 实例演⽰三种继承关系下基类成员的各类型成员访问关系的变化
//class Person
//{
//public:
//	void Print()
//	{
//		cout << _name << endl;
//	}
//protected:
//	string _name; // 姓名
//private:
//	int _age; // 年龄
//};
//
////class Student : protected Person
////class Student : private Person
//class Student : public Person
//{
//protected:
//	int _stunum; // 学号
//};#include<vector>
#include<stack>
//namespace ming
//{//template<class T>//class vector//{};// stack和vector的关系，既符合is-a，也符合has-a
//	template<class T>
//	class stack : public std::vector<T>
//	{
//	public:
//		void push(const T& x)
//		{
//			// 基类是类模板时，需要指定⼀下类域，
//			// 否则编译报错:error C3861: “push_back”: 找不到标识符
//			// 因为stack<int>实例化时，也实例化vector<int>了
//// 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到
//			vector<T>::push_back(x);
//			//push_back(x);
//		}
//		void pop()
//		{
//			vector<T>::pop_back();
//		}
//		const T& top()
//		{
//			return vector<T>::back();
//		}
//		bool empty()
//		{
//			return vector<T>::empty();
//		}
//	};
//}
//int main()
//{
//	ming::stack<int> st;
//	st.push(1);
//	st.push(2);
//	st.push(3);
//	while (!st.empty())
//	{
//		cout << st.top() << " ";
//		st.pop();
//	}
//	return 0;
//}
//
//class Person
//{
//protected:
//	string _name; // 姓名
//	string _sex; // 性别
//	int _age; // 年龄
//};
//class Student : public Person
//{
//public:
//	int _No; // 学号
//};
//int main()
//{
//	Student sobj;
//	// 1.派⽣类对象可以赋值给基类的指针/引⽤
//	Person* pp = &sobj;
//	Person& rp = sobj;
//	// ⽣类对象可以赋值给基类的对象是通过调⽤后⾯会讲解的基类的拷⻉构造完成的
//	Person pobj = sobj;
//	//2.基类对象不能赋值给派⽣类对象，这⾥会编译报错
//	sobj = pobj;
//	return 0;
//}// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是⾮常容易混淆
//class Person
//{
//protected:
//	string _name = "⼩李⼦"; // 姓名
//	int _num = 111; // ⾝份证号
//};
//class Student : public Person
//{
//public:
//	void Print()
//	{
//		cout << " 姓名:" << _name << endl;
//		cout << " ⾝份证号:" << Person::_num << endl;
//		cout << " 学号:" << _num << endl;
//	}
//protected:
//	int _num = 999; // 学号
//};
//int main()
//{
//	Student s1;
//	s1.Print();
//	return 0;
//};
//
//class A
//{
//public:
//	void fun()
//	{
//		cout << "func()" << endl;
//	}
//};
//class B : public A
//{
//public:
//	void fun(int i)
//	{
//		cout << "func(int i)" << i << endl;
//	}
//};
//int main()
//{
//	B b;
//	b.fun(10);
//	b.fun();
//	return 0;
//};//class Person
//	 {
//public:
//	Person(const char* name = "peter")
//		: _name(name)
//		 {
//		cout << "Person()" << endl;
//	}
//	Person(const Person& p)
//		: _name(p._name)
//	{
//		cout << "Person(const Person& p)" << endl;
//	}
//	Person& operator=(const Person& p)
//	{
//		cout << "Person operator=(const Person& p)" << endl;
//		if (this != &p)
//			_name = p._name;
//		return *this;
//	}
//	~Person()
//	{
//		cout << "~Person()" << endl;
//	}
//	 protected:
//		 string _name; // 姓名
//};
//class Student : public Person
//{
//public:
//	Student(const char* name, int num)
//		: Person(name)
//		, _num(num)
//	{
//		cout << "Student()" << endl;
//	}
//	Student(const Student& s)
//		: Person(s)
//		, _num(s._num)
//	{
//		cout << "Student(const Student& s)" << endl;
//	}
//	Student& operator = (const Student& s)
//	{
//		cout << "Student& operator= (const Student& s)" << endl;
//		if (this != &s)
//		{
//			// 构成隐藏，所以需要显⽰调⽤
//			Person::operator =(s);
//			_num = s._num;
//		}
//		return *this;
//	}
//	~Student()
//	{
//		cout << "~Student()" << endl;
//	}
//protected:
//	int _num; //学号
//};
//int main()
//{
//	Student s1("jack", 18);
//	Student s2(s1);
//	Student s3("rose", 17);
//	s1 = s3;
//	return 0;
//}// C++98
//class Person
//{
//private:
//	Person(string name = "Peter")
//		:_name(name)
//	{}
//};
//
//// C++11
//class Person final
//{
//public:
//	Person(string name = "Peter")
//		:_name(name)
//	{}
//	~Person()
//	{
//		cout << "基类析构" << endl;
//	}
//};
//
//class Student;
//class Person
//{
//public:
//	friend void Display(const Person& p, const Student& s);
//protected:
//	string _name; // 姓名
//};
//class Student : public Person
//{
//protected:
//	int _stuNum; // 学号
//};
//void Display(const Person& p, const Student& s)
//{
//	cout << p._name << endl;
//	cout << s._stuNum << endl;
//}
//int main()
//{
//	Person p;
//	Student s;
//	// 编译报错：error C2248: “Student::_stuNum”: ⽆法访问 protected 成员
//	// 解决⽅案：Display也变成Student 的友元即可
//	Display(p, s);
//	return 0;
//}//class Person
//{
//public:
//	string _name;
//	static int _count;
//};
//int Person::_count = 0;
//class Student : public Person
//{
//protected:
//	int _stuNum;
//};
//int main()
//{
//	Person p;
//	Student s;
//	// 这⾥的运⾏结果可以看到⾮静态成员_name的地址是不⼀样的
//	// 说明派⽣类继承下来了，⽗派⽣类对象各有⼀份
//	cout << &p._name << endl;
//	cout << &s._name << endl;
//	// 这⾥的运⾏结果可以看到静态成员_count的地址是⼀样的
//	// 说明派⽣类和基类共⽤同⼀份静态成员
//	cout << &p._count << endl;
//	cout << &s._count << endl;
//	// 公有的情况下，⽗派⽣类指定类域都可以访问静态成员
//	cout << Person::_count << endl;
//	cout << Student::_count << endl;
//	return 0;
//}//class Person
//{
//public:
//	string _name; // 姓名
//};
//class Student : public Person
//{
//protected:
//	int _num; //学号
//};
//class Teacher : public Person
//{
//protected:
//	int _id; // 职⼯编号
//};
//class Assistant : public Student, public Teacher
//{
//protected:
//	string _majorCourse; // 主修课程
//};
//int main()
//{
//	// 编译报错：error C2385: 对“_name”的访问不明确
//	Assistant a;
//	a._name = "peter";
//	// 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决
//	a.Student::_name = "xxx";
//	a.Teacher::_name = "yyy";
//	return 0;
//}//class Person
//{
//public:
//	string _name; // 姓名
//	/*int _tel;
//	* int _age;
//string _gender;
//string _address;*/
//// ...
//};
//// 使⽤虚继承Person类
//class Student : virtual public Person
//{
//protected:
//	int _num; //学号
//};
//// 使⽤虚继承Person类
//class Teacher : virtual public Person
//{
//protected:
//	int _id; // 职⼯编号
//};
//// 教授助理
//class Assistant : public Student, public Teacher
//{
//protected:
//	string _majorCourse; // 主修课程
//};
//int main()
//{
//	// 使⽤虚继承，可以解决数据冗余和⼆义性
//	Assistant a;
//	a._name = "peter";
//	return 0;
//}class Person
{
public:Person(const char* name):_name(name){}string _name; // 姓名
};
class Student : virtual public Person
{
public:Student(const char* name, int num):Person(name), _num(num){}
protected:int _num; //学号
};
class Teacher : virtual public Person
{
public:Teacher(const char* name, int id):Person(name), _id(id){}
protected:int _id; // 职⼯编号
};
// 不要去玩菱形继承
class Assistant : public Student, public Teacher
{
public:Assistant(const char* name1, const char* name2, const char* name3):Person(name3), Student(name1, 1), Teacher(name2, 2){}
protected:string _majorCourse; // 主修课程
};
int main()
{// 思考⼀下这⾥a对象中_name是"张三", "李四", "王五"中的哪⼀个？Assistant a("张三", "李四", "王五");return 0;
}template<class CharT, class Traits = std::char_traits<CharT>>
class basic_ostream : virtual public std::basic_ios<CharT, Traits>
{};
template<class CharT, class Traits = std::char_traits<CharT>>
class basic_istream : virtual public std::basic_ios<CharT, Traits>
{};// Tire(轮胎)和Car(⻋)更符合has-a的关系
class Tire {
protected:string _brand = "Michelin"; // 品牌size_t _size = 17; // 尺⼨
};
class Car {
protected:string _colour = "⽩⾊"; // 颜⾊string _num = "陕ABIT00"; // ⻋牌号Tire _t1; // 轮胎Tire _t2; // 轮胎Tire _t3; // 轮胎Tire _t4; // 轮胎
};
class BMW : public Car {
public:void Drive() { cout << "好开-操控" << endl; }
};
// Car和BMW/Benz更符合is-a的关系
class Benz : public Car {
public:void Drive() { cout << "好坐-舒适" << endl; }
};
template<class T>
class vector
{};
// stack和vector的关系，既符合is-a，也符合has-a
template<class T>
class stack : public vector<T>
{};
template<class T>
class stack
{
public:vector<T> _v;
};
int main()
{return 0;
}
http://www.lryc.cn/news/602789.html

相关文章：

  • Ansible+Shell框架中，如何管理敏感信息
  • [蓝牙通信] NimBLE init启动 | 时间抽象-转换
  • C语言基础第15天：从数组指针到指针函数
  • 快速构建基于React.js的用户注册与登录的Web应用程序
  • 图像识别边缘算法
  • 数学建模算法-day[13]
  • QGIS基于规则的道路分级制图及Leaflet集成展示实例
  • Polkadot 的 Web3 哲学：从乔布斯到 Gavin Wood 的数字自由传承
  • 开始记录一步步学习pcl
  • Go语言--＞变量
  • DBAPI 实现分页查询的两种方法
  • 若依【（前后端分离版）SpringBoot+Vue3】
  • JVM 笔记：类加载、内存管理、垃圾收集与垃圾收集器
  • JVM 垃圾回收机制全景解析：从对象回收到收集算法
  • C++---初始化列表（initializer_list）
  • Flutter在购物场景中BLoC的应用
  • shell每日三题大神之路：第三天
  • 轻量级远程开发利器：Code Server与cpolar协同实现安全云端编码
  • AR眼镜：工业4.0时代高风险作业的安全守护者
  • 深度思考和搜索研究 最新的GSPO强化学习算法
  • 解决 xshell 无法连接win10 、win11的linux子系统
  • python每日一题练习
  • Java集合遍历的几种方式
  • 【docker】DM8达梦数据库的docker-compose以及一些启动踩坑
  • Thymeleaf th:object核心用法精解
  • LeetCode｜Day28｜67. 二进制求和｜Python刷题笔记
  • OpenLayers 入门指南【四】：项目初始化
  • org.hibernate.hql.internal.ast.QuerySyntaxException: Invalid path
  • 下载k8s官方组件chart和容器镜像
  • 自动化测试常用函数