c++ —— 继承

懒洋洋。。。。。。。

已于 2025-04-23 17:00:02 修改

阅读量1k

点赞数 30

分类专栏： c++ 文章标签： c++

于 2025-04-23 16:59:37 首次发布

本文链接：https://blog.csdn.net/shsbyshdbdhjsk/article/details/147313021

版权

c++ 专栏收录该内容

13 篇文章

订阅专栏

一、继承的概念

继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许我们在保持原有特性的基础上进行扩展，增加方法（成员函数）和属性（成员变量），这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认识过程。以前我们接触的函数层次的复用，继承是类设计层次的复用。

下面我们看到没有继承之前我们设计了两个类student和Teacher,Student 和 Teacher都有姓名/地址/电话/年龄等成员变量，都有identity成分认证的成员函数，如果设计两个就是多余的所以这个函数就可以使用继承

下面我们公共的成员都放到Person类中，Student和teacher都继承Person,都可以复用这些成员，就不需要重复定义了，省去了很多麻烦

二、继承的格式

（1）定义格式

下面我们看到Person是基类，也称父类。Student是派生类，也称子类

（2）继承方法

（3）访问限定符

（4）继承基类成员访问方式的变化

基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类，但是语法上限制派生类对象不管在类里面还是在外面都不能去访问它。
基类private成员在派生类中是不能被访问的，如果基类成员不想再类外直接被访问，但需要在派生类中能被访问，就定义为protected。可以看出保护成员限定符是因继承才出现的
实际上面的表格我们总结一下就会发现，基类的私有成员在派生类都是不可见的。基类的其他成员在派生类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protecte > private。
使用关键字class 时默认的继承方式是private,使用struct 时默认的继承方式是public,不过最好显示的写出继承方式
在实际运用中一般使用的都是public继承，几乎很少使用projected/private继承，也不提倡使用protetced/private继承，因为protected/private继承下来的成员，也不提倡使用 protected/private继承，因为projected/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

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

public继承的派生类对象可以赋值给基类的指针/基类的引用。这里有个形象的说法叫做切片或者切割。寓意把派生类中基类那部分切出来，基类指针或引用指向的是派生类中切出来的基类那部分。
基类对象不能赋值给派生类对象（但是派生类对象可以复制给基类的对象）
基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果时多态类型可以使用RTT的dynamic _cast 来进行识别后进行安全转换

四、继承中的作用域

隐藏规则:

（1）在继承体系中基类和派生类都有独立的作用域

（2）派生类和基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏.(在派生类函数中，可以使用基类：：基类成员显示访问)

（3）需要注意的是如果是同名函数的隐藏，只需要函数名相同就构成隐藏

（4）注意在实际中体系继承体系里面最好不要定义同名的成员。

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

将基类整体看做一个自定义类型的成员变量

4个常见默认成员函数

派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
派生类的拷贝函数必须调用基类的拷贝构造完成基类的拷贝初始化
派生类的operater= 必须调用基类的operator=完成基类的复制。需要注意的是派生类的 operator= 隐藏了基类的operator= ，需要指定基类作用域

派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员在清理类成员的顺序
派生类对象初始化先调用基类构造在调用派生类构造。（先父后子）
派生类对象析构清理先调用派生类在调用基类的析构（先子后父）

因为多态中一些场景析构函数需要构成重写，重写的条件之一是函数名相同，那么编译器会对析构函数名进行特殊处理，处理成destructor（），所以基类析构函数不加virtual的情况下，派生类析构函数和基类析构函数构成隐藏关系

如上图编译器会自动调用基类的析构

#include <iostream>
using namespace std;
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++新增了一个final关键字，修饰基类，派生类就不能继承了。

七、继承和友元

友元关系不能继承

八、继承与静态成员

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

class Person
{
public:
	string _name;
	static int _count;
};
int Person::_count = 0;
class Student :public Person
{
public:
	int _stuNum;
};
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;
	cout << &Student:: _count << endl;
	return 0;
}

这里的运行结果可以看见非静态成员_name的地址是不一样的，说明派生类继承下来，夫派生类对象各有一份，但是静态成员变量一样只有一份，公有的情况下，夫派生类指定类域可以访问静态变量

九、多继承和菱形问题

1、单继承问题

一个派生类只有一个直接基类的称呼这个继承关系为单继承

2、多继承问题

一个派生类有两个及以上的基类这种继承关系为多继承，多继承对象在内存中的模型是，先继承的基类在前面，后面继承的基类在后面，派生类成员放在后面

3、菱形继承

菱形继承是多继承的一种，即下面这种，存在二义性和数据冗余

（1）冗余

assistant里面有两份person成员

（2）二义性

如果我们想通过assistant 去调用person的可调用成员，我们并不知道调用的是哪一个只能通过指定类域的形式解决，但是冗余解决不了

class Person
{
public:
	string _name;
	//static int _count;
};
//int Person::_count = 0;
class Student :public Person
{
public:
	int _stuNum;
};
class Teacher : public Person
{
public:
	int _id;
};
class assistant :public Teacher, public Student
{
protected:
	string _subject;
};
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;
	cout << &Student:: _count << endl;*/
	assistant a;
	a.Person::_name = "wenjie";
	a.Student::_name = "jie";
	return 0;
}

十、虚继承

为了解决彻底解决二义性和冗余我们引入virtual，放在Student 和 Teacher的位置,Student和Teacher 不会都继承Person的代码,而是将Person的代码提取出来放在文件的开头或者结尾，让所有人共用一份

1、但是不要轻易去使用玩菱形继承

求a对象中的_name会是谁

答案：王五，虽然他们会共用一个Person的代码，但是只有在person（“王五”）的时候会走person的构造，其他是不会走的，但是在构造的时候必须要写，不然会报错

但是在这个时候就是

person的值就是张三

2、多继承中的指针偏移问题

p3 = =p1 != p2

十一、继承和组合

public继承是一种is-a的关系。也就是说每个派生类都是一个基类对象

组合是一种has-a的关系，假设B结合了A，每个B对象中都有一个A对象（比如仿函数）

继承允许你根据基类的实现来定义派⽣类的实现。这种通过⽣成派⽣类的复⽤通常被称为⽩箱复⽤
(white-box reuse)。术语“⽩箱”是相对可视性⽽⾔：在继承⽅式中，基类的内部细节对派⽣类可
⻅。继承⼀定程度破坏了基类的封装，基类的改变，对派⽣类有很⼤的影响。派⽣类和基类间的依赖关系很强，耦合度⾼。

对象组合是类继承之外的另⼀种复⽤选择。新的更复杂的功能可以通过组装或组合对象来获得。对
象组合要求被组合的对象具有良好定义的接⼝。这种复⽤⻛格被称为⿊箱复⽤(black-box reuse)，
因为对象的内部细节是不可⻅的。对象只以“⿊箱”的形式出现。组合类之间没有很强的依赖关
系，耦合度低。优先使⽤对象组合有助于你保持每个类被封装。

优先使⽤组合，⽽不是继承。实际尽量多去⽤组合，组合的耦合度低，代码维护性好。不过也不太
那么绝对，类之间的关系就适合继承(is-a)那就⽤继承，另外要实现多态，也必须要继承。类之间的