【C++】继承-EW帮帮网

文章目录

1 继承的概念及定义
2. 基类和派生类间的转换
3. 继承中的作用域
- 3.1 隐藏规则：
4. 派生类的默认成员函数
- 4.1 4个常见默认成员函数
- 4.2 无法被继承的类
5. 继承与友元
6. 继承与静态成员
7. 多继承及其菱形继承问题
8. 继承和组合

1 继承的概念及定义

1.1 继承的概念

继承是一种面向对象编程机制，允许一个类（派生类）获取另一个类（基类）的成员变量和成员函数，并可以在此基础上进行扩展或修改。通过继承，派生类可以复用基类的代码，同时可以添加新功能或重写基类方法以实现多态。继承支持不同的访问控制（public、protected、private），决定了基类成员在派生类中的可见性。

1.2 继承定义

1.2.1 定义格式

下面我们看到Person是基类，也称作父类。Student是派生类，也称作子类。(因为翻译的原因，所以
既叫基类/派生类，也叫父类/子类)
在这里插入图片描述

1.2.2 访问说明符

在这里插入图片描述

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

#include <iostream>
using namespace std;

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; // 学号
};

1.3 继承类模板

#include <vector>
namespace zkp
{
	//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()
{
	zkp::stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
	return 0;
}

2. 基类和派生类间的转换

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

class Person
{
	protected :
	string _name; // 姓名
	string _sex; // 性别
	int _age; // 年龄
};
class Student : public Person
{
	public :
	int _No; // 学号
};
int main()
{
	Student sobj;
	Person* pp = &sobj;
	Person& rp = sobj;
	Person pobj = sobj;
	// 这里会报错
	sobj = pobj;
	return 0;
}

我们前面说的是派生类指针/引用可以赋值给基类的指针/引用，而不能反过来。你可以把拥有更多东西的物品切掉一部分变成另一个拥有更少东西的物品，却不能让那个更少物品的东西凭空产生东西变成更多的一个物品。

3. 继承中的作用域

3.1 隐藏规则：

在继承体系中基类和派生类都有独立的作用域。
派生类和基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。（在派生类成员函数中，可以使用基类::基类成员显示访问)
需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
注意在实际中在继承体系里面最好不要定义同名的成员。

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

注意：
编译器仅在派生类作用域内查找匹配函数，不会自动搜索基类作用域的同名函数。即使基类有更匹配的版本，也会因隐藏而被忽略。
在这里插入图片描述

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

4.1 4个常见默认成员函数

6个默认成员函数，默认的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢?

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

4.2 无法被继承的类

方法1：基类的构造函数私有，派生类的构成必须调用基类的构造函数，但是基类的构成函数私有化以后，派生类看不见就不能调用了，那么派生类就无法实例化出对象。
方法2：C++11新增了一个 final关键字，final修改基类，派生类就不能继承了。

// C++11
class Base final
{
public:
	void func5() { cout << "Base::func5" << endl; }
protected:
	int a = 1;
private:
	// C++98
	/*Base()
	{}*/
};

5. 继承与友元

友元关系不能继承，也就是说基类友元不能访问派生类私有和保护成员。
很好理解，你父亲的朋友不一定是你的朋友吧，就这么个意思。

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

6. 继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个派生类，都只有一个static成员实例。
例如，基类是人，里面存在一个 static int _count是用来统计人数的，而人有很多职业，如：老师、警察、社畜。不管怎样他们都是人，所以在基类中使用一个 static int _count 统计数量就可以了。

7. 多继承及其菱形继承问题

7.1 继承模型

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

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

菱形继承：

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

在这里插入图片描述

7.2 虚继承

为了解决菱形继承的问题，C++ 引入了虚继承。它通过确保最顶层的基类在继承体系中只存在一个共享实例，避免数据冗余和访问歧义。

class A { public: int a; };
class B : public A {};       // 普通继承
class C : public A {};       // 普通继承
class D : public B, public C {}; // D 包含两份 A 的成员（B::a 和 C::a）

此时 D 对象中存在两份 A 的成员，访问 d.a 会引发歧义。

虚继承的解决方案：

class A { public: int a; };
class B : virtual public A {};  // 虚继承
class C : virtual public A {};  // 虚继承
class D : public B, public C {}; // D 中仅保留一份 A 的成员

virtual 关键字确保 A 在继承体系中只有一个共享实例。
访问 d.a 时不再歧义，直接指向唯一的 A 实例。

7.3 多继承中指针偏移问题

前面谈多继承的时候我们提到过，先继承的基类在前面，后面继承的基类在后面，派生类成员在放到最后面，通过指针偏移问题，我们就能看出来一些特点了。

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;

	cout << p1 << endl;
	cout << p2 << endl;
	cout << p3 << endl;

	return 0;
}

在这里插入图片描述
通过结果我们不难看出，Base1部分存在于 Derive 的头部，而 Base2 存在于 Base1 的后面，在我们使用 Derive* p3 = &d; 的时候，因为是取整个对象的头部地址，所以它的值和 p1 的相等。

8. 继承和组合

public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
继承允许你根据基类的实现来定义派生类的实现。在继承方式中，基类的内部细节对派生类可见。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
优先使用组合，而不是继承。实际尽量多去用组合，组合的耦合度低，代码维护性好。不过也不太那么绝对，类之间的关系就适合继承(is-a)那就用继承，另外要实现多态，也必须要继承。类之间的关系既适合用继承(is-a)也适合组合(has-a)，就用组合。

is-a 关系：

// 基类：交通工具
class Vehicle {
public:
    void startEngine() { /* 启动引擎 */ }
};

// 派生类：汽车是一种交通工具
class Car : public Vehicle {
public:
    void drive() { /* 驾驶逻辑 */ }
};

// 使用
Car car;
car.startEngine();  // 直接复用基类方法
car.drive();

has-a 关系：

// 引擎类（独立组件）
class Engine {
public:
    void start() { /* 启动逻辑 */ }
};

// 汽车类包含引擎
class Car {
private:
    Engine engine;  // 组合关系
public:
    void drive() { 
        engine.start();  // 委托调用
        /* 驾驶逻辑 */ 
    }
};

// 使用
Car car;
car.drive();

【C++】继承