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

C++知识整理day9——继承（基类与派生类之间的转换、派生类的默认成员函数、多继承问题）

news 来源：原创 2025/6/7 12:06:19

文章目录

  • 1.继承的概念和定义
  • 2.基类与派生类之间的转换
  • 3.继承中的作用域
  • 4.派生类的默认成员函数
  • 5.实现一个不能被继承的类
  • 6.继承与友元
  • 7.继承与静态成员
  • 8.多继承和菱形继承问题
    • 8.1 继承分类及菱形继承
    • 8.2 虚继承

1.继承的概念和定义

概念： 继承(inheritance)机制是⾯向对象程序设计使代码可以复⽤的最重要的⼿段，它允许我们在保持原有类特性的基础上进⾏扩展，增加⽅法(成员函数)和属性(成员变量)，这样产⽣新的类，称派⽣类或子类。继承呈现了⾯向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的函数层次的复⽤，继承是类设计层次的复⽤。

下⾯我们看到没有继承之前我们设计了两个类Student和Teacher，Student和Teacher都有姓名/地址/电话/年龄等成员变量，都有identity⾝份认证的成员函数，设计到两个类⾥⾯就是冗余的。当然他们也有⼀些不同的成员变量和函数，⽐如⽼师独有成员变量是职称，学⽣的独有成员变量是学号；学⽣的独有成员函数是学习，⽼师的独有成员函数是授课。

class Student
{
public:
	void identify()
	{
		//...
	}
	void study()
	{
		//...
	}
protected:
	string _name = "sun";//姓名
	string _address;//地址
	string _tel;//电话
	int _age = 24;//年龄

	int _id;//学号
};

class Teacher
{
public:
	void identify()
	{
		//...
	}
	void teaching()
	{
		//...
	}
protected:
	string _name = "zhangsan";//姓名
	string _address;//地址
	string _tel;//电话
	int _age = 24;//年龄

	int _title;//职称
};

我们可以看到，学生类和老师类是有很多重复项的；下⾯我们公共的成员都放到Person类中，Student和teacher都继承Person，就可以复⽤这些成员，就不需要重复定义了，省去了很多⿇烦。

class Person
{
public:
	void identify()
	{
		//...
	}
protected:
	string _name = "sun";//姓名
	string _address;//地址
	string _tel;//电话
	int _age = 24;//年龄;
};

class Student : public Person
{
public:
	void study()
	{
		//...
	}
protected:
	int _id;
};

class Teacher : public Person
{
public:
	void teaching()
	{
		//...
	}
protected:
	int _title;
};

==定义：==下⾯我们看到Person是基类，也称作⽗类。Student是派⽣类，也称作⼦类。(因为翻译的原因，所以既叫基类/派⽣类，也叫⽗类/⼦类)
在这里插入图片描述
继承方式有public继承、protected继承和private继承三种。
访问限定符也有public访问、protected访问和private访问三种。

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

类成员/继承方式public继承protected继承private继承
基类的public成员派生类的public成员派生类的protected成员派生类的private成员
基类的protected成员派生类的protected成员派生类的protected成员派生类的private成员
基类的private成员不可见不可见不可见

总结：

  1. 基类private成员在派⽣类中⽆论以什么⽅式继承都是不可⻅的。这⾥的不可⻅是指基类的私有成员还是被继承到了派⽣类对象中，但是语法上限制派⽣类对象不管在类⾥⾯还是类外⾯都不能去访问它。
  2. 基类private成员在派⽣类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派⽣类中能访问，就定义为protected。 可以看出保护成员限定符是因继承才出现的。
  3. 实际上⾯的表格我们进⾏⼀下总结会发现，基类的私有成员在派⽣类都是不可⻅。基类的其他成员在派⽣类的访问⽅式 == Min(成员在基类的访问限定符，继承⽅式)，public > protected > private。
  4. 使⽤关键字class时默认的继承⽅式是private，使⽤struct时默认的继承⽅式是public，不过最显示的写出继承⽅式。
  5. 在实际运⽤中⼀般使⽤都是public继承，⼏乎很少使⽤protetced/private继承，也不提倡使protetced/private继承，因为protetced/private继承下来的成员都只能在派⽣类的类⾥⾯使⽤，实际中扩展维护性不强。

这里有一个特例：就是当基类是类模板时，需要指定⼀下类域。示例：

namespace sun
{
	template<class T>
	class stack : public std::vector<T>
	{
	public:
		void push(const T& x)
		{
			// 基类是类模板时，需要指定⼀下类域，
			// 否则编译报错:error C3861: “push_back”: 找不到标识符
			vector<T>::push_back(x);
			// 因为stack<int>实例化时，也实例化vector<int>了
			// 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到
		}
	};
}

2.基类与派生类之间的转换

  • public继承的派⽣类对象 可以赋值给 基类的指针 / 基类的引⽤。这⾥有个形象的说法叫切⽚或者切割。寓意把派⽣类中基类那部分切出来，基类指针或引⽤指向的是派⽣类中切出来的基类那部分。
  • 基类对象不能赋值给派⽣类对象。
  • 基类的指针或者引⽤可以通过强制类型转换赋值给派⽣类的指针或者引⽤。但是必须是基类的指针是指向派⽣类对象时才是安全的。这⾥基类如果是多态类型，可以使⽤RTTI(Run-Time Type Information)dynamic_cast 来进⾏识别后进⾏安全转换。（ps：这个我们后⾯类型转换章节再单独专⻔讲解，这⾥先提⼀下）

在这里插入图片描述
示例：

class Person
{
protected:
	string _name;
	string _sex;
	int _age;
};

class Student : public Person
{
private:
	int _id;
};

int main()
{
	Student s1;
	//派生类的对象可以直接赋值给基类的指针或者引用
	Person* pp = &s1;
	Person& p = s1;

	return 0;
}

3.继承中的作用域

规则：

  1. 在继承体系中基类和派⽣类都有独⽴的作⽤域。
  2. 派⽣类和基类中有同名成员，派⽣类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。（在派⽣类成员函数中，可以使⽤ 基类::基类成员 显⽰访问）
  3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
  4. 注意在实际中在继承体系⾥⾯最好不要定义同名的成员。

示例：

//_num构成了隐藏关系
//派生类对象不指定作用域的情况下，会优先使用派生类的_num
class Person
{
protected:
	string _name;
	int _num;
};

class Student : public Person
{
public:
	void Print()
	{

	}
protected:
	int _num;//学号
};

阅读如下一段代码，回答以下两道选择题。

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;
};

  1. A和B类中的两个func构成什么关系（B）
    A. 重载 B. 隐藏 C.没关系

  2. 下⾯程序的编译运⾏结果是什么（A）
    A. 编译报错 B. 运⾏报错 C. 正常运⾏

4.派生类的默认成员函数

6个默认成员函数，默认的意思就是指我们不写，编译器会变我们⾃动⽣成⼀个，那么在派⽣类中，这⼏个成员函数是如何⽣成的呢？

  1. 派⽣类的构造函数必须调⽤基类的构造函数初始化基类的那⼀部分成员。如果基类没有默认的构造函数，则必须在派⽣类构造函数的初始化列表阶段显⽰调⽤。
  2. 派⽣类的拷贝构造函数必须调⽤基类的拷贝构造完成基类的拷贝初始化。
  3. 派⽣类的operator=必须要调⽤基类的operator=完成基类的复制。需要注意的是派⽣类的operator=隐藏了基类的operator=，所以显⽰调⽤基类的operator=，需要指定基类作⽤域。
  4. 派⽣类的析构函数会在被调⽤完成后⾃动调⽤基类的析构函数清理基类成员。因为这样才能保证派⽣类对象先清理派⽣类成员再清理基类成员的顺序。
  5. 派⽣类对象初始化先调⽤基类构造再调派⽣类构造。
  6. 派⽣类对象析构清理先调⽤派⽣类析构再调基类的析构。
  7. 因为多态中⼀些场景析构函数需要构成重写，重写的条件之⼀是函数名相同(这个我们多态章节会讲解)。那么编译器会对析构函数名进⾏特殊处理，处理成destructor()，所以基类析构函数不加virtual的情况下，派⽣类析构函数和基类析构函数构成隐藏关系。

在这里插入图片描述
示例：我们来写一个案例

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
	Person(const char* name = "sun")
		:_name(name)
	{
		cout << "Person()" << endl;
	}
	Person(const Person& p)
		:_name(p._name)
	{
		cout << "Perosn(const Person& p)" << endl;
	}
	Person& operator==(const Person& p)
	{
		cout << "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 id)
		:Person(name)
		,_id(id)
	{
		cout << "Stuent(const char* name, int id)" << endl;
	}
	Student(const Student& s)
		:Person(s)
		,_id(s._id)
	{
		cout << "Student(const Student& s)" << endl;
	}
	Student& operator==(const Student& s)
	{
		cout << "Student& operator==(const Student& s)" << endl;
		if (this != &s)
		{
			//构成隐藏，必须显示调用
			Person::operator==(s);
			_id = s._id;
		}
		return *this;
	}
	~Student()
	{
		cout << "~Student()" << endl;
	}
protected:
	int _id;//学号
};

int main()
{
	Student s1("sun", 24);
	Student s2(s1);
	Student s3("tong", 18);
	s1 = s3;
	return 0;
}

下面我们来看一下详细的运行结果：
在这里插入图片描述

5.实现一个不能被继承的类

  • 方法一：把基类的构造函数设置成私有，因为派生类继承了基类对象，派生类在调用自己的构造函数时，必须要调用基类的构造函数。但是基类的构造函数成了私有之后，派生类对象就无法调用，那也就没法实例化派生类对象了 。（C98方法）
  • 方法二：C++11提供了一个final关键字，final修改基类，就无法被其他类继承了。（推荐使用方法二）注意：final关键字写在类名的后面

示例：

class Person final
{
public:
	Person(const char* name = "sun")
		:_name(name)
	{
		cout << "Person()" << endl;
	}
	Person(const Person& p)
		:_name(p._name)
	{
		cout << "Perosn(const Person& p)" << endl;
	}
	Person& operator==(const Person& p)
	{
		cout << "operator==(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;
		return *this;
	}
	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name;//名字
};

6.继承与友元

结论：友元关系不可以被继承，也就是说基类的友元不可以访问派生类中的私有和保护成员。

示例：
在这里插入图片描述
解决方案：把Display也变成Student类的友元。

7.继承与静态成员

结论：基类定义了static静态成员，则整个继承体系里面只能有一个这样的成员。无论派生出多少个派生类，都只有一个static成员。

示例：

class Student;

class Person
{
public:
	string _name;
	static int _count;//静态成员变量只能类内声明，类外定义！！！
};

int Person::_count = 0;

class Student : public Person
{
protected:
	int _id;//学号
};

int main()
{
	Person p;
	Student s;
	cout << &p._name << endl;
	cout << &s._name << endl;

	cout << &p._count << endl;
	cout << &s._count << endl;

	//共有的情况下，父类或派生类可以指定类域访问静态成员
	cout << Person::_count << endl;

	return 0;
}

在这里插入图片描述

8.多继承和菱形继承问题

8.1 继承分类及菱形继承

  • 单继承：⼀个派⽣类只有⼀个直接基类时称这个继承关系为单继承
  • 多继承：⼀个派⽣类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型时，先继承的基类在前⾯，后⾯继承的基类在后⾯，派⽣类成员在放到最后⾯。
  • 菱形继承：菱形继承是多继承的⼀种特殊情况。菱形继承的问题，从下⾯的对象成员模型构造，可以看出菱形继承有 数据冗余和⼆义性 的问题，在Assistant的对象中Person成员会有两份。⽀持多继承就⼀定会有菱形继承，像Java就直接不⽀持多继承，规避掉了这⾥的问题，所以实践中我们也是不建议设计出菱形继承这样的模型的。

在这里插入图片描述
示例：

class Person
{
public:
	string _name;
};


class Student : public Person
{
protected:
	int _id;//学号
};

class Teacher : public Person
{
protected:
	int _num;//编号
};

class Assistant : public Student, public Teacher
{
protected:
	string _course;//课程
};

int main()
{
	Assistant a;
	//a._name = "sun";//编译报错，E0266	"Assistant::_name" 不明确


	//需要指明哪个基类下的成员-》解决二义性
	a.Student::_name = "zhangsan";
	a.Teacher::_name = "lisi";

	return 0;
}

8.2 虚继承

很多⼈说C++语法复杂，其实多继承就是⼀个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂，性能也会有⼀些损失，所以最好不要设计出菱形继承。多继承可以认为是C++的缺陷之⼀，后来的⼀些编程语⾔都没有多继承，如Java。

class Person
{
public:
	string _name; // 姓名
};
// 使⽤虚继承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;
}

注意：我们可以设计出多继承，但是不建议设计出菱形继承，因为菱形虚拟继承以后，⽆论是使⽤还是底层
都会复杂很多。当然有多继承语法⽀持，就⼀定存在会设计出菱形继承，像Java是不⽀持多继承的，
就避开了菱形继承。

虚继承的底层很复杂，编译器会为虚继承的类创建一个虚基类表（VBT，Virtual Base Table），其中存储指向虚基类的指针（VBP，Virtual Base Pointer）。我们最好不要使用菱形继承。

下面我们以一道题目收尾！！！

class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main()
{
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;
	return 0;
}

多继承中指针偏移问题？下⾯说法正确的是( C )
A：p1 == p2 == p3 B：p1 < p2 < p3 C：p1 == p3 != p2 D：p1 != p2 != p3

【解析】对于p1和p2使我们上面的切片操作，而p3单纯就是派生类的指针，所以p3指向d的初始位置。但是呢
在这里插入图片描述
我们看这幅图可以清晰的看出三个指针的指向。

相关文章：

  • Linux(Centos 7.6)命令详解：uniq
  • 【愚公系列】《Python网络爬虫从入门到精通》034-DataFrame简单数据计算整理
  • 表单制作代码，登录动画背景前端模板
  • 2025网络安全等级测评报告，信息安全风险评估报告（Word模板）
  • DeepSeek开源周Day2：DeepEP - 专为 MoE 模型设计的超高效 GPU 通信库
  • win11 24h2 远程桌面 频繁断开 已失去连接 2025
  • 通过Python编程语言实现“机器学习”小项目教程案例
  • Ollama微调
  • 猿大师播放器：网页内嵌VLC/FFPlayer在Web端直接播放RTSP/RTMP/H.265视频流
  • （Arrow）试时间处理变得更简单
  • 【Linux Oracle】time命令+oracle exp压缩
  • 分享httprunner 结合django实现平台接口自动化方案
  • QT各种版本下载安装
  • 【初阶数据结构】星河中的光影 “排” 象：排序（下）
  • 计算机网络————（三）
  • 性能测试基础知识点
  • RGMII（Reduced Gigabit Media Independent Interface）详解
  • 【论文分享02】A brief introduction to weakly supervised learning
  • 如何选择更安全的无人自助管理私人影院物联网框架？
  • 谈谈 ES 6.8 到 7.10 的功能变迁（4）- 聚合功能篇
  • app 展示网站/优化营商环境建议
  • 北京手机网站建设公司排名/郑州网络运营培训
  • 凤岗建设网站/个人免费域名注册网站
  • 湖北网站建设哪里有/互联网线上推广
  • wordpress标签重定向/重庆seo优
  • 马格南摄影网站/网络营销推广方案策划书