【c++随笔12】继承
【c++随笔12】继承
- 一、继承
-
- 1、继承的概念
- 2、3种继承方式
- 3、父类和子类对象赋值转换
- 4、继承中的作用域——隐藏
- 5、继承与友元
- 6、继承与静态成员
- 二、继承和子类默认成员函数
-
- 1、子类构造函数
- 二、子类拷贝构造函数
-
- 3、子类的赋值重载
- 4、子类析构函数
- 三、单继承、多继承、菱形继承
-
- 1、单继承：一个子类只有一个直接父类，我们称这种继承关系为单继承。
- 2、多继承：一个子类有两个或以上直接父类，我们称这种继承关系为多继承。
- 3、菱形继承（Diamond Inheritance）是指在类继承关系中，存在一个派生类同时继承自两个直接或间接基类，并且这两个基类又共同继承自一个共同的基类，从而形成了菱形状的继承结构。
-
- 3.1、菱形继承可能引发以下问题：
- 3.2、为了解决菱形继承带来的问题，可以采用以下方法：
- 4、继承和组合
原创作者：郑同学的笔记
原创地址：https://zhengjunxue.blog.csdn.net/article/details/131795289
qq技术交流群：921273910
C++ 是基于面向对象的程序，面向对象有三大特性 —— 封装、继承、多态。
一、继承
1、继承的概念
- 继承（inheritance）机制是面向对象程序设计，使代码可以复用的最重要的手段。
- 它允许程序员在保持原有类特性的基础上进行扩展，以增加功能。这样产生新的类，称为派生类。
- 继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。
- 以前我们接触的复用都是函数复用，而继承是类设计层次的复用。
#include 输出
- 继承的定义格式
Student 是 子类，我们也称之为派生类。Person 是父类，我们也称之为 基类。
class 派生类名:［继承方式］ 基类名{
派生类新增加的成员
};
2、3种继承方式
- 访问限定符：public / protected / private
下表汇总了不同继承方式对不同属性的成员的影响结果
| 继承方式/基类成员 | public成员 | protected成员 | private成员 |
|---|---|---|---|
| public继承 | public | protected | 不可见 |
| protected继承 | protected | protected | 不可见 |
| private继承 | private | private | 不可见 |
由于 private 和 protected 继承方式会改变基类成员在派生类中的访问权限，导致继承关系复杂，所以实际开发中我们一般使用 public。
3、父类和子类对象赋值转换
- 子类对象可以赋值给父类的对象、父类的指针、父类的引用：
#include 输出
注意事项：
- ① 父类对象不能赋值给子类对象
Student s; // 子类
Person p; // 父类
s = p; ❌
- ② 父类的指针可以通过强转赋值给子类的指针，但是必须是父类的指针是指向子类对象时才是安全的。
这里父类如果是多态类型，可以使用 RTTI（Run-Time Type Information，即运行时类型识别）的 dynamic_cast 来进行识别后进行安全转换。
#include 4、继承中的作用域——隐藏
- 继承体系中的父类和子类都有独立的作用域，如果子类和父类有同名成员，
- 此时子类成员会屏蔽父类对同名成员的直接访问，这种情况叫做 “隐藏” （有文章把它叫重定义，其实我不建议这种叫法，因为重定义指的是同一个作用域重复定义）。
在子类成员函数中，可以使用如下方式进行显式访问：
基类::基类成员
–
例如：在Student类中
Person::print()
#include 5、继承与友元
- 友元关系不能继承，也就是说父类友元不能访问子类私有和保护成员！
#include 报错
“Student::m_stuID”: 无法访问 protected 成员(在“Student”类中声明)
6、继承与静态成员
- 父类定义了 static 静态成员，则整个继承体系里面中有一个这样的成员。
可以理解为共享，父类的静态成员可以在子类共享，父类和子类都能去访问它。
无论派生出多少个子类，都只有一个 static 成员实例：
#include 输出
二、继承和子类默认成员函数
1、子类构造函数
- 子类的构造函数必须调用父类的构造函数初始化父类的那一部分成员。
如果 父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显式调用。(如下面的demo)
- 子类对象初始化先调用父类构造再调子类构造。
#include 思考：如何设计一个不能被继承的类？
- 将父类的构造函数私有化：
class A
{
private:
A() {}
};
父类的构造函数私有化后，在父类的外部，父类自己也没法初始化了？
（单例模式可以这么做，如下）
class A {
public:
static A CreateObject() { // 提供一个获取对象的方式
return A();
}
private:
A() {}
};
class B : public A {};
int main(void)
{
A a = A::CreateObject();
return 0;
}
二、子类拷贝构造函数
- 子类的拷贝构造函数必须调用父类的拷贝构造完成拷贝初始化。
#include 输出
3、子类的赋值重载
- 子类的 operator= 必须要调用父类的 operator= 完成父类的复制。
#include 输出
4、子类析构函数
- 为了保证子类对象先清理子类成员再清理父类成员的顺序，先子后父。
子类析构先子后父，子类对象的析构清理是先调用子类析构再调父类析构。
- 子类析构函数完成后会自动调用父亲的析构函数，所以不需要我们显式调用。
#include 输出
三、单继承、多继承、菱形继承
1、单继承：一个子类只有一个直接父类，我们称这种继承关系为单继承。
2、多继承：一个子类有两个或以上直接父类，我们称这种继承关系为多继承。
3、菱形继承（Diamond Inheritance）是指在类继承关系中，存在一个派生类同时继承自两个直接或间接基类，并且这两个基类又共同继承自一个共同的基类，从而形成了菱形状的继承结构。
下面是一个示例代码来说明菱形继承的概念：
class Animal {
public:
void eat() {
cout << "Animal eats." << endl;
}
};
class Mammal : public Animal {
public:
void run() {
cout << "Mammal runs." << endl;
}
};
class Bird : public Animal {
public:
void fly() {
cout << "Bird flies." << endl;
}
};
class Bat : public Mammal, public Bird {
public:
void sleep() {
cout << "Bat sleeps." << endl;
}
};
在上述代码中，Animal 是基类，Mammal 和 Bird 是直接派生类，而 Bat 是通过多重继承同时派生自 Mammal 和 Bird 的派生类。注意到 Mammal 和 Bird 都继承自 Animal，这就形成了菱形继承结构。
3.1、菱形继承可能引发以下问题：
- 二义性（Ambiguity）：由于 Bat 同时继承自 Mammal 和 Bird，如果两个基类都定义了相同的成员函数或变量，编译器就无法确定该使用哪个版本，从而导致二义性错误。
- 冗余数据：由于两个基类都继承自同一个基类 Animal，当 Bat 对象被创建时，会在内存中存在两份相同的 Animal 的数据。
3.2、为了解决菱形继承带来的问题，可以采用以下方法：
- 使用虚拟继承（Virtual Inheritance）：在 Mammal 和 Bird 继承 Animal 时，使用 virtual 关键字表示虚拟继承，这样就可以消除冗余数据和二义性问题。
class Mammal : virtual public Animal {
// ...
};
class Bird : virtual public Animal {
// ...
};
- 使用间接继承：在 Bat 类中只直接继承 Mammal 或 Bird 的一个，而间接继承另一个基类的成员函数或变量。
class Bat : public Mammal {
private:
Bird bird;
public:
// 使用 bird 对象来访问 Bird 类中的成员
};
菱形继承是多重继承中的一种特殊情况，需要谨慎使用，并采取适当的解决方案来避免引发问题。
4、继承和组合
- 继承和组合 public继承是一种 is-a 的关系。也就是说每个派生类对象都是一个基类对象。
- 组合是一种 has-a 的关系。假设B组合了A，每个B对象中都有一个A对象。
- 优先使用对象组合，而不是类继承 。
- 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用 （white-box reuse）。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。 继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关 系很强，耦合度高。
- 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对 象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用（black-box reuse）， 因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。 组合类之间没有很强的依赖关系， 耦合度低。优先使用对象组合有助于你保持每个类被封装。
- 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适 合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。
class A {
// ...
};
// 继承
class B : public A {};
class C {
// ...
};
// 组合
class D {
C _c;
};
继承就是团体出行，A 任何成员的修改都有可能影响 B 的实现。
组合就是自由出行，C 只要不修改公有，就不会对 D 有影响。