【C++篇】继承之巅:超越法则束缚,领略面向对象的至臻智慧

CSDN 2024-10-12 08:05:12 阅读 61

文章目录

C++ 继承详解:虚拟继承与进阶实战前言第一章:继承与友元、静态成员1.1 继承与友元1.1.1 友元函数的定义

1.2 继承与静态成员1.2.1 静态成员的继承与访问

第二章:复杂的菱形继承及虚拟继承2.1 菱形继承问题2.1.1 菱形继承的基本结构

2.2 菱形继承的二义性问题2.3 解决方案:虚拟继承2.3.1 虚拟继承的定义

2.4 虚基表(VBTable)与虚基类指针(VBPTR)2.4.1 虚基表的工作机制2.4.2 偏移量的用途

2.5 虚拟继承的优缺点2.5.1 优点2.5.2 缺点

第三章:虚拟继承与多态应用3.1 虚拟继承与多态的结合3.1.1 虚基类中的虚函数与多态

3.2 虚拟继承的注意事项3.2.1 构造函数中的调用顺序3.2.2 虚基类成员的访问

第四章:虚拟继承与传统继承的对比4.1 虚拟继承与传统继承的区别4.1.1 实例化方式的区别4.1.2 内存布局的区别

4.2 选择传统继承还是虚拟继承?4.2.1 何时使用传统继承?4.2.2 何时使用虚拟继承?

4.3 虚拟继承的最佳实践4.3.1 小心使用多层次的虚拟继承

4.4 实际项目中的继承选择案例4.4.1 案例:设计多功能打印机

第五章:继承的总结与反思5.1 C++ 继承的核心要点回顾5.2 常见继承误区与陷阱5.2.1 忽视虚析构函数的定义

5.2 优先使用组合而非继承5.3 继承的设计模式与应用5.3.1 工厂模式的应用

5.4 继承的未来发展趋势

写在最后

C++ 继承详解:虚拟继承与进阶实战

💬 欢迎讨论:在学习过程中,如果有任何疑问或想法,欢迎在评论区留言一起讨论。

👍 点赞、收藏与分享:觉得这篇文章对你有帮助吗?记得点赞、收藏并分享给更多的朋友吧!你们的支持是我不断进步的动力!

🚀 分享给更多人:如果你觉得这篇文章对你有帮助,欢迎分享给更多对 C++ 感兴趣的朋友,一起学习进步!


前言

接上篇【C++篇】继承之韵:解构编程奥义,感悟面向对象的至高法则

C++ 继承机制在面向对象编程中扮演着至关重要的角色。继承不仅能够帮助我们复用代码,还能够通过多态实现灵活的程序设计。在上一篇文章中,我们深入探讨了继承的基础知识与常见用法。在本篇文章中,我们将进一步探讨更复杂的继承机制,特别是虚拟继承,以及如何通过虚拟继承来解决多重继承中的难题。


第一章:继承与友元、静态成员

1.1 继承与友元

在 C++ 中,友元是一种特殊机制,它允许指定的非成员函数或者其他类访问类的私有成员和保护成员。然而,友元关系不能继承,也就是说,基类的友元不会自动成为派生类的友元,反之亦然。

1.1.1 友元函数的定义

如果基类定义了一个友元函数,该友元函数只能访问基类的私有和保护成员,而不能访问派生类的私有或保护成员。反之,如果友元函数在派生类中定义,它也无法访问基类的私有和保护成员。

示例代码:

<code>class Person { -- -->

public:

friend void Display(const Person& p); // 声明友元函数

protected:

string _name = "Alice"; // 姓名

};

void Display(const Person& p) {

cout << "Name: " << p._name << endl; // 友元函数可以访问_person中的私有成员

}

class Student : public Person {

protected:

int _studentID = 1001; // 学号

};

int main() {

Student s;

Display(s); // 友元函数只能访问基类的保护成员

// 无法访问Student类中的_studentID

return 0;

}

在以上代码中,Display 函数是 Person 类的友元,它可以访问 Person 的保护成员 _name。但是,即使 Display 函数可以操作 Student 对象,它也无法访问 Student 类中的 _studentID 成员。

1.2 继承与静态成员

C++ 中的静态成员在继承关系中具有一些特殊的行为。无论继承了多少次,基类中的静态成员在整个继承体系中始终只有一个实例。派生类可以共享访问基类中的静态成员

1.2.1 静态成员的继承与访问

基类定义的静态成员在派生类中共享。无论派生类如何使用该静态成员,它们操作的都是同一个静态成员变量。

示例代码:

class Person {

public:

static int _count; // 静态成员,用于计数

Person() { ++_count; }

};

int Person::_count = 0; // 初始化静态成员

class Student : public Person {

};

int main() {

Student s1;

Student s2;

cout << "Person count: " << Person::_count << endl; // 输出 2

cout << "Student count: " << Student::_count << endl; // 输出 2,Student类共享Person类的静态成员

return 0;

}

在以上代码中,_countPerson 类的静态成员,用于统计创建的 Person 对象数量。由于 Student 类继承自 Person,因此 Student 也可以访问 _count。无论是通过 Person::_count 还是 Student::_count,它们都指向同一个静态成员。

在这里插入图片描述


第二章:复杂的菱形继承及虚拟继承

2.1 菱形继承问题

菱形继承是 C++ 多重继承中的一种特殊情况。当一个类从两个基类继承,而这两个基类又有共同的基类时,就会形成一个菱形结构。菱形继承会导致基类的多次实例化,进而引发数据冗余和二义性问题

2.1.1 菱形继承的基本结构

在菱形继承中,子类会直接或间接继承自同一个基类,形成一个“菱形”的继承结构,这样的设计很容易导致基类的数据被重复继承。

下图展示了菱形继承的结构:

在这里插入图片描述

在这里插入图片描述

简单示例代码:

<code>class A { -- -->

public:

int _a;

};

class B : public A {

};

class C : public A {

};

class D : public B, public C {

};

在上述代码中,D 类通过 BC 间接继承了 A,这就形成了一个菱形结构。D 类中实际上会有两份 _a,分别属于从 BC 继承来的 A。这就导致了数据冗余和访问的二义性。

2.2 菱形继承的二义性问题

二义性问题 是指在访问基类成员时,编译器无法确定访问的是哪一个基类实例。例如,D 类对象在访问 _a 时,编译器无法判断是访问 B 中的 _a 还是 C 中的 _a

示例代码:

int main() {

D d;

d._a = 5; // 错误:二义性

return 0;

}

在这个例子中,d._a 会导致编译错误,因为编译器无法决定 _a 是从 B 还是从 C 继承的 A 中访问的。这种二义性问题在实际开发中会带来严重的维护和理解困难。

2.3 解决方案:虚拟继承

虚拟继承可以解决菱形继承中的数据冗余和二义性问题。通过虚拟继承,派生类会共享同一个虚基类的实例,从而避免基类被多次实例化。

2.3.1 虚拟继承的定义

虚拟继承通过在继承时使用 virtual 关键字,指示编译器在继承关系中只生成一个基类实例,从而解决数据冗余和二义性问题。

class A

{

public:

int _a;

};

// class B : public A

class B : virtual public A

{

public:

int _b;

};

// class C : public A

class C : virtual public A

{

public:

int _c;

};

class D : public B, public C

{

public:

int _d;

};

int main()

{

D d;

d.B::_a = 1;

d.C::_a = 2;

d._b = 3;

d._c = 4;

d._d = 5;

return 0;

}

在这里,BC 虚拟继承了 A,这样在 D 类中,A 的实例只存在一份。

2.4 虚基表(VBTable)与虚基类指针(VBPTR)

在虚拟继承中,编译器会在每个虚基类对象中加入一个指向虚基表(VBTable)的指针,即虚基类指针(VBPTR),用于存储偏移量信息。

2.4.1 虚基表的工作机制

虚基表中存储的是虚基类相对于派生类对象的偏移量。通过虚基类指针,派生类对象可以在运行时计算出虚基类在内存中的实际位置。

示例内存布局:

0x005EF75C 处存储了 D 对象的起始地址。虚基类指针(VBPTR)指向虚基表(VBTable)。虚基表中的偏移量帮助定位虚基类 AD 对象内存中的实际位置。

在这里插入图片描述

2.4.2 偏移量的用途

偏移量的设计让编译器能够在运行时调整虚基类的位置,确保派生类在访问基类成员时能够定位到唯一的基类实例。

在虚拟继承中,虚基表中的偏移量解决了菱形继承中的访问问题,使得派生类 <code>D 能够直接访问基类 A 的成员,而不会再有二义性。

int main() { -- -->

D d;

d._a = 5; // 正确:通过虚基表解决了二义性

return 0;

}

此时,D 对象通过虚基表定位到 A 的唯一实例,d._a 可以正确访问到基类 A 中的成员。

2.5 虚拟继承的优缺点

2.5.1 优点

解决数据冗余问题:虚拟继承可以确保在菱形继承中,基类只有一个实例,避免了数据冗余。消除访问的二义性:通过虚基表和虚基类指针,派生类可以唯一地访问到虚基类的实例,消除了访问时的二义性问题。

2.5.2 缺点

内存开销增加:虚拟继承引入了虚基表和虚基类指针,有时候增加了内存的额外开销。(但当虚基类很大的时候,其实还是节省了空间)性能开销:每次访问虚基类成员时,都需要通过虚基表进行偏移计算,这可能带来一定的性能开销。


第三章:虚拟继承与多态应用

3.1 虚拟继承与多态的结合

虚拟继承在解决菱形继承问题的同时,也为实现多态提供了更高的灵活性。通过使用 virtual 关键字,我们不仅可以避免基类的重复实例化,还可以确保派生类对象通过基类指针或引用来访问重写后的方法。

3.1.1 虚基类中的虚函数与多态

这里先大致看一下,之后会有专门讲解多态的文章滴

在多态机制中,基类的函数被声明为虚函数(virtual)后,派生类可以对该函数进行重写(override)。通过基类的指针或引用调用该函数时,实际运行时会调用派生类的版本,这就是多态的核心。

class A {

public:

virtual void show() {

cout << "Base A" << endl;

}

};

// 虚拟继承确保 A 在 D 中只有一个实例

class B : virtual public A {

public:

void show() override {

cout << "Derived B" << endl;

}

};

class C : virtual public A {

public:

void show() override {

cout << "Derived C" << endl;

}

};

class D : public B, public C {

public:

void show() override {

cout << "Derived D" << endl;

}

};

int main() {

D d;

A* pa = &d; // 基类指针指向派生类对象

pa->show(); // 输出 "Derived D"

return 0;

}

在上述代码中,通过虚拟继承,D 类对象 d 中只有一个 A 的实例。A 类的虚函数 show()D 类重写后,通过基类指针 pa 调用时,实际调用的是 D 类的 show() 方法,实现了多态。

3.2 虚拟继承的注意事项

3.2.1 构造函数中的调用顺序

使用虚拟继承时,基类的构造函数调用顺序会略有不同。虚基类总是最先被初始化,无论虚基类是在继承链中出现的位置。

class A {

public:

A() { cout << "Constructing A" << endl; }

};

class B : virtual public A {

public:

B() { cout << "Constructing B" << endl; }

};

class C : virtual public A {

public:

C() { cout << "Constructing C" << endl; }

};

class D : public B, public C {

public:

D() { cout << "Constructing D" << endl; }

};

int main() {

D d;

return 0;

}

输出

Constructing A

Constructing B

Constructing C

Constructing D

在这个例子中,即使 A 类作为虚基类出现于 BC 的虚拟继承中,在 D 的构造过程中,A 的构造函数仍然是最先被调用的。虚基类的这种初始化顺序确保 A 的实例在 BC 之前就已经准备好。

3.2.2 虚基类成员的访问

虚基类成员的访问在派生类中可能需要显式地指定基类。虽然虚拟继承解决了二义性,但为了代码的可读性,通常仍然使用 类名::成员名 的形式来访问。

class A {

public:

int _value;

};

class B : virtual public A {

};

class C : virtual public A {

};

class D : public B, public C {

public:

void setValue(int val) {

A::_value = val; // 显式指定访问A的_value

}

int getValue() {

return A::_value;

}

};

int main() {

D d;

d.setValue(10);

cout << "Value: " << d.getValue() << endl; // 输出 "Value: 10"

return 0;

}

在此示例中,D 类中通过 A::_value 来访问 A 中的 _value 成员。虽然虚拟继承避免了数据冗余,但使用显式的访问方式可以增强代码的可读性。


第四章:虚拟继承与传统继承的对比

4.1 虚拟继承与传统继承的区别

虚拟继承和传统继承在多重继承中的处理方式存在明显差异。理解这两者的区别有助于在实际项目中做出合适的设计选择。

4.1.1 实例化方式的区别

在传统继承中,当多个派生类继承自同一个基类时,基类会被每个派生类实例化一次,从而导致数据冗余。而虚拟继承通过 virtual 关键字使得基类在派生类中只实例化一次,避免了冗余。

示例代码对比:

传统继承

class A {

public:

int _a;

};

class B : public A {

};

class C : public A {

};

class D : public B, public C {

};

int main() {

D d;

// d.B::_a 和 d.C::_a 是不同的两个变量,导致数据冗余。

return 0;

}

在上述代码中,D 类中存在两份 A_a 变量,这就导致了数据冗余问题。

虚拟继承

class A {

public:

int _a;

};

class B : virtual public A {

};

class C : virtual public A {

};

class D : public B, public C {

};

int main() {

D d;

// d._a 是唯一的,避免了数据冗余。

return 0;

}

在虚拟继承的版本中,A 的实例在 D 中只存在一份,因此 d._a 是唯一的。这解决了传统继承中的数据冗余问题。

4.1.2 内存布局的区别

在虚拟继承中,编译器通过引入虚基表(VBTable)和虚基类指针(VBPTR),使得派生类对象可以通过偏移量访问到基类的数据。传统继承则直接将基类对象的数据存储在派生类对象中。

传统继承的内存布局:派生类对象中包含每个基类对象的数据。虚拟继承的内存布局:派生类对象通过虚基表定位到唯一的虚基类实例。

4.2 选择传统继承还是虚拟继承?

在实际项目中,选择传统继承还是虚拟继承,取决于代码的需求以及对继承结构的复杂性管理。以下是一些建议和注意事项:

4.2.1 何时使用传统继承?

单一继承:如果类的设计只涉及到一个基类和一个派生类,那么使用传统继承即可,不需要引入虚拟继承的复杂性。没有菱形继承的问题:如果类的多重继承不会导致基类的重复实例化(即没有菱形结构),传统继承是更简单的选择。性能要求高的场景:由于传统继承不涉及虚基表的查找,访问速度更快,适用于性能要求更高的场景。

4.2.2 何时使用虚拟继承?

解决菱形继承问题:如果设计中存在菱形继承结构,虚拟继承是解决数据冗余和二义性问题的首选。共享基类资源:当多个派生类需要共享同一个基类的资源(如单个计数器实例),虚拟继承可以确保资源的唯一性。更强的扩展性:虚拟继承在类的设计上提供了更高的灵活性,使得以后扩展新的派生类时,不会因为基类的重复实例化而产生冲突。

4.3 虚拟继承的最佳实践

4.3.1 小心使用多层次的虚拟继承

虚拟继承可以解决菱形继承的问题,但如果继承层次过多,代码的可读性和维护性会大幅降低。因此,在设计类层次结构时,应尽量保持清晰和简洁。

减少继承层次:尽量避免多层次的虚拟继承,保持类的结构简单化。使用组合替代继承:如果可以使用对象组合(has-a 关系)替代继承(is-a 关系),那么优先选择组合,这样可以降低代码的耦合度。

4.4 实际项目中的继承选择案例

4.4.1 案例:设计多功能打印机

假设我们要设计一个多功能打印机(MFP),它可以进行打印、扫描和复印。我们可以通过多重继承来实现这三种功能。

基类 Printer:提供打印功能。基类 Scanner:提供扫描功能。派生类 Copier:继承自 PrinterScanner,实现复印功能。

如果我们希望 Copier 共享 PrinterScanner 的基础硬件(如设备接口),可以使用虚拟继承,确保 Copier 只有一个 Device 实例。

class Device {

public:

void connect() {

cout << "Device connected" << endl;

}

};

class Printer : virtual public Device {

public:

void print() {

cout << "Printing..." << endl;

}

};

class Scanner : virtual public Device {

public:

void scan() {

cout << "Scanning..." << endl;

}

};

class Copier : public Printer, public Scanner {

public:

void copy() {

cout << "Copying..." << endl;

}

};

int main() {

Copier copier;

copier.connect(); // 调用唯一的Device实例的方法

copier.print();

copier.scan();

copier.copy();

return 0;

}

在这个案例中,PrinterScanner 虚拟继承自 DeviceCopier 只会持有一个 Device 的实例,确保设备连接的资源不会被重复使用。


第五章:继承的总结与反思

5.1 C++ 继承的核心要点回顾

在学习 C++ 继承的过程中,我们探讨了多种继承方式及其实际应用场景。以下是一些关键要点的总结:

继承的本质:继承是面向对象编程的核心特性,允许派生类复用基类的属性和方法,从而避免代码的重复编写。继承通过 is-a 关系体现类之间的层次关系。多重继承与菱形继承:多重继承允许一个类从多个基类继承,但也引入了复杂性,特别是菱形继承问题。虚拟继承通过 virtual 关键字,可以解决菱形继承中的数据冗余和二义性问题。虚基表与偏移量:虚拟继承通过虚基表(VBTable)和虚基类指针(VBPTR),在运行时动态计算虚基类的位置,从而保证了多重继承中的唯一性。

5.2 常见继承误区与陷阱

在实际开发中,继承的使用容易出现一些常见的误区和陷阱,以下是几个需要特别注意的点:

5.2.1 忽视虚析构函数的定义

当基类的析构函数未被声明为 virtual 时,通过基类指针删除派生类对象,会导致派生类的析构函数无法正确调用,从而引发内存泄漏。

也是多态的内容,下一篇博客就会讲解

class Base {

public:

~Base() { cout << "Base destructor called" << endl; }

};

class Derived : public Base {

public:

~Derived() { cout << "Derived destructor called" << endl; }

};

int main() {

Base* p = new Derived();

delete p; // 只调用了Base的析构函数,未调用Derived的析构函数,导致内存泄漏

return 0;

}

在上述代码中,delete p 只会调用 Base 的析构函数,而不会调用 Derived 的析构函数。解决方法是将 Base 的析构函数声明为 virtual

5.2 优先使用组合而非继承

在设计类时,组合优先于继承是一种常见的设计原则。组合关系使类之间的耦合度降低,更便于代码的扩展和维护。

例如,如果我们有一个 Car 类和一个 Engine 类,可以通过组合的方式来实现,而不是让 Car 继承自 Engine

class Engine {

public:

void start() { cout << "Engine started" << endl; }

};

class Car {

private:

Engine _engine; // Car组合了一个Engine对象

public:

void start() {

_engine.start();

cout << "Car is running" << endl;

}

};

通过组合,我们可以更灵活地替换和扩展 Engine 类,而不会影响 Car 类的设计。

5.3 继承的设计模式与应用

在 C++ 开发中,继承与组合是实现多态的重要手段。合理地使用继承,可以实现更灵活的设计模式,如工厂模式策略模式等。这些设计模式广泛应用于实际项目中,有助于提高代码的复用性和扩展性。

5.3.1 工厂模式的应用

工厂模式利用继承机制,实现对象的动态创建和管理,是设计模式中的经典应用之一。

class Product {

public:

virtual void use() = 0; // 定义一个抽象产品类

};

class ConcreteProductA : public Product {

public:

void use() override { cout << "Using Product A" << endl; }

};

class ConcreteProductB : public Product {

public:

void use() override { cout << "Using Product B" << endl; }

};

class Factory {

public:

static Product* createProduct(int type) {

if (type == 1) {

return new ConcreteProductA();

} else {

return new ConcreteProductB();

}

}

};

int main() {

Product* product = Factory::createProduct(1);

product->use(); // 输出 "Using Product A"

delete product;

return 0;

}

在这个例子中,通过继承 Product 类,我们实现了对不同产品对象的动态创建和管理。

5.4 继承的未来发展趋势

随着 C++ 标准的不断演进,新的语言特性(如 std::variantconcepts)提供了更多替代继承的方式。对于未来的 C++ 开发者来说,理解这些新特性,并在合适的场景下替代传统继承,将会成为新的挑战和机遇。


写在最后

通过本篇文章的学习,我们深入探讨了 C++ 继承中的进阶知识,包括多重继承、虚拟继承的使用和内存管理,以及它们在实际项目中的应用。虚拟继承在解决菱形继承问题的同时,也增加了代码的复杂性,因此在使用时需要格外谨慎。

继承是面向对象编程中的利器,但也是一把双刃剑。合理地使用继承可以大大提高代码的复用性和可扩展性,而不合理的继承则会带来维护上的负担。

在设计类结构时,务必根据实际需求选择最适合的方案,掌握继承的精髓,才能在 C++ 编程中游刃有余。

💬 讨论区:如果你在学习过程中有任何疑问,欢迎在评论区留言讨论。

👍 支持一下:如果你觉得这篇文章对你有帮助,请点赞、收藏并分享给更多 C++ 学习者!你的支持是我继续创作的动力。


以上就是关于【C++篇】继承之巅:超越法则束缚,领略面向对象的至臻智慧的内容啦,各位大佬有什么问题欢迎在评论区指正,或者私信我也是可以的啦,您的支持是我创作的最大动力!❤️

在这里插入图片描述



声明

本文内容仅代表作者观点,或转载于其他网站,本站不以此文作为商业用途
如有涉及侵权,请联系本站进行删除
转载本站原创文章,请注明来源及作者。