【C++ 多态】了解 C++ 中的类型擦除和虚拟函数调用-阿里云开发者社区

第一章类型擦除（Type Erasure）

1.1 类型擦除的定义

类型擦除（Type Erasure）是一种编程技术，它允许我们在编译时忽略类型的具体信息，从而可以在运行时处理不同类型的对象。在C++中，类型擦除通常通过使用模板和虚拟函数实现。

在口语交流中，我们可以这样描述类型擦除：“Type Erasure allows us to ignore the specific type information at compile time and handle different types of objects at runtime."（类型擦除让我们在编译时忽略具体的类型信息，从而可以在运行时处理不同类型的对象。）

在这个句子中，“allows us to”（让我们）是一个常见的短语，用来描述一种能力或可能性。“at compile time”（在编译时）和"at runtime"（在运行时）是两个常见的计算机科学术语，分别指的是在编译程序时和运行程序时。

类型擦除是一种强大的技术，它可以让我们编写更加通用和灵活的代码。例如，std::function就是一个使用类型擦除的例子。std::function可以存储任何可以调用的对象，无论这个对象的类型是什么。这是通过类型擦除实现的。

下面是一个使用std::function的代码示例：

#include <iostream>
#include <functional>
void printNumber(int i) {
    std::cout << "Number: " << i << std::endl;
}
int main() {
    // 创建一个std::function对象，它可以存储任何可以接受一个int参数的函数
    std::function<void(int)> func;
    // 将printNumber函数存储到std::function对象中
    func = printNumber;
    // 调用存储在std::function对象中的函数
    func(42);
    return 0;
}

在这个例子中，std::function<void(int)>是一个可以存储任何可以接受一个int参数的函数的对象。我们可以将任何符合这个条件的函数，无论它的具体类型是什么，存储到这个std::function对象中。这就是类型擦除的作用。

第二章类型擦除(Type Erasure)

类型擦除(Type Erasure)是一种编程技术，它允许我们在编译时忽略类型的具体信息，从而使我们能够编写更加通用和灵活的代码。在C++中，类型擦除通常通过模板和虚拟函数实现。

2.1 设计意图

类型擦除的主要设计意图是提供一种方式，使得我们可以在编译时忽略类型的具体信息，从而使我们能够编写更加通用和灵活的代码。这种技术在很多场合都非常有用，例如，当我们需要在一个容器中存储不同类型的对象时，或者当我们需要编写可以处理任意类型的函数时。

2.2 使用场景

类型擦除在很多场合都非常有用，例如：

在一个容器中存储不同类型的对象。例如，std::any和std::function就是使用类型擦除实现的。它们可以存储任意类型的值，而不需要在编译时知道这些值的具体类型。
编写可以处理任意类型的函数。例如，std::function可以存储任意的可调用对象，包括函数、函数指针、lambda表达式和函数对象。

2.3 底层原理

类型擦除的底层原理通常涉及到模板和虚拟函数。在C++中，我们可以使用模板来编写可以处理任意类型的代码。然而，模板的一个限制是它们在编译时需要知道所有的类型信息。这就是类型擦除发挥作用的地方。通过使用类型擦除，我们可以在运行时处理类型信息，从而使我们能够编写更加通用和灵活的代码。

类型擦除通常通过以下步骤实现：

定义一个基类，这个基类包含一个或多个虚拟函数。
对于每个需要擦除的类型，定义一个派生类。这个派生类覆盖基类的虚拟函数，以提供对应类型的实现。
使用基类的指针或引用来存储和操作派生类的对象。这样，我们就可以在运行时处理类型信息，而不需要在编译时知道这些信息。

2.4 实际案例

让我们通过一个实际的案例来看看类型擦除是如何在C++中工作的。这个案例来自于Dave Kilian的博客文章"C++ ‘Type Erasure’ Explained"。

2.4.1 案例背景

假设我们有几个动物类，如Cow，Pig和Dog，它们都有see()和say()方法，但是它们并没有从一个共同的基类继承。我们希望能够将这些动物统一到一个公共的基类中，但是我们无法修改这些动物类的实现。

2.4.2 使用模板实现多态

我们可以使用模板来实现多态。例如，我们可以定义一个模板函数seeAndSay()，这个函数可以接受任何有see()和say()方法的对象：

template <typename T>
void seeAndSay(const T& animal) {
    std::cout << animal.see() << " says " << animal.say() << std::endl;
}

然后，我们可以使用这个函数来处理任何类型的动物：

Cow cow;
Pig pig;
Dog dog;
seeAndSay(cow);  // 输出 "Cow sees Pig says Oink"
seeAndSay(pig);  // 输出 "Pig sees Dog says Woof"
seeAndSay(dog);  // 输出 "Dog sees Cow says Moo"

2.4.3 使用类型擦除实现多态

虽然模板可以实现多态，但是它有一些限制。例如，我们不能将不同类型的动物放入一个数组中。为了解决这个问题，我们可以使用类型擦除。

首先，我们定义一个接口类MyAnimal，这个类有两个虚拟函数see()和say()：

class MyAnimal {
public:
    virtual std::string see() const = 0;
    virtual std::string say() const = 0;
};

然后，我们定义一个模板类AnimalWrapper，这个类继承自MyAnimal，并且包装了一个动物对象：

template <typename T>
class AnimalWrapper : public MyAnimal {
public:
    AnimalWrapper(const T& animal) : animal_(animal) {}
    std::string see() const override {
        return animal_.see();
    }
    std::string say() const override {
        return animal_.say();
    }
private:
    T animal_;
};

现在，我们可以使用AnimalWrapper来创建MyAnimal的对象，并且将这些对象放入一个数组中：

std::vector<std::unique_ptr<MyAnimal>> animals;
animals.push_back(std::make_unique<AnimalWrapper<Cow>>({
}

第三章：虚拟函数调用 (Virtual Function Invocation)

虚拟函数调用是C++中实现动态多态（Dynamic Polymorphism）的主要机制。它允许我们在运行时根据对象的实际类型来决定调用哪个函数，这是通过虚函数表（Virtual Table，通常被称为vtable）来实现的。

3.1 设计意图 (Design Intent)

虚拟函数调用的主要设计意图是实现动态多态。在C++中，多态是通过基类指针或引用调用派生类的函数实现的。这允许我们编写可以处理基类和派生类的通用代码，而不需要知道对象的实际类型。

例如，你可能有一个Animal基类和几个派生类，如Dog和Cat。每个类都有一个makeSound函数，但是实现不同。通过使用虚函数，你可以通过一个Animal指针调用正确的makeSound函数，无论这个指针实际指向的是Dog对象还是Cat对象。

3.2 使用场景 (Use Cases)

虚拟函数调用主要用于以下场景：

当你有一个函数，它需要处理基类和多个派生类，并且需要根据对象的实际类型来调用正确的函数时。
当你需要在运行时决定调用哪个函数时。

3.3 底层原理 (Underlying Principles)

虚拟函数调用的底层原理涉及到虚函数表。每个有虚函数的类都有一个虚函数表，这个表包含了类的所有虚函数的地址。当我们通过基类指针调用虚函数时，编译器会查找虚函数表，找到正确的函数，然后调用它。

这是虚拟函数调用的流程图：

3.4 代码示例：使用虚拟函数实现多态

下面是一个使用虚拟函数实现多态的代码示例：

class Animal {
public:
    virtual void makeSound() const {
        std::cout << "(silence)" << std::endl;
    }
};
class Dog : public Animal {
public:
    void makeSound() const override {
        std::cout << "Woof!" << std::endl;
    }
};
class Cat : public Animal {
public:
    void makeSound() const override {
       
```cpp
        std::cout << "Meow!" << std::endl;
    }
};
void letItSpeak(const Animal& animal) {
    animal.makeSound();
}
int main() {
    Dog dog;
    Cat cat;
    letItSpeak(dog);  // 输出：Woof!
    letItSpeak(cat);  // 输出：Meow!
    return 0;
}

在这个例子中，letItSpeak函数接受一个Animal的引用作为参数，然后调用makeSound函数。由于makeSound是一个虚函数，所以实际调用的函数取决于传递给letItSpeak的对象的实际类型。如果传递的是Dog对象，就调用Dog::makeSound；如果传递的是Cat对象，就调用Cat::makeSound。

3.5 代码示例：虚拟函数与动态绑定

虚拟函数的一个重要特性是动态绑定（Dynamic Binding）。动态绑定意味着函数的选择是在运行时进行的，而不是在编译时。这是通过虚函数表实现的。

下面是一个展示动态绑定的代码示例：

class Base {
public:
    virtual void print() const {
        std::cout << "Base" << std::endl;
    }
};
class Derived : public Base {
public:
    void print() const override {
        std::cout << "Derived" << std::endl;
    }
};
void print(const Base& obj) {
    obj.print();
}
int main() {
    Derived d;
    print(d);  // 输出：Derived
    return 0;
}

在这个例子中，print函数接受一个Base的引用作为参数，然后调用print函数。由于print是一个虚函数，所以实际调用的函数取决于传递给print的对象的实际类型。即使print函数的参数类型是Base，但是如果传递的是Derived对象，就调用Derived::print。这就是动态绑定的作用。

第四章：类型擦除与虚拟函数调用的交互 (Interaction between Type Erasure and Virtual Function Calls)

4.1 类型擦除如何利用虚拟函数 (How Type Erasure Utilizes Virtual Function Calls)

类型擦除(Type Erasure)和虚拟函数调用(Virtual Function Calls)在C++中是紧密相关的。类型擦除的实现通常依赖于虚拟函数来实现多态性(Polymorphism)。

在C++中，虚拟函数(Virtual Functions)是实现运行时多态性(Runtime Polymorphism)的一种机制。当我们有一个指向基类(Base Class)的指针或引用，并且通过这个指针或引用调用一个虚拟函数时，C++运行时系统会根据这个指针或引用实际指向的对象的类型来决定调用哪个函数。这就是虚拟函数调用的基本原理。

类型擦除(Type Erasure)则是一种技术，它允许我们在编译时忽略对象的实际类型，而在运行时恢复这个类型。这通常是通过创建一个包含虚拟函数的接口(Interface)，并为每个需要被擦除类型的类创建一个实现这个接口的包装类(Wrapper Class)来实现的。这个接口的虚拟函数就是我们需要在运行时动态调用的函数。

例如，std::function就是一个使用类型擦除的例子。它可以存储任何可调用对象(Callable Object)，无论这个对象的类型是什么。这是通过创建一个内部的接口，这个接口有一个虚拟的调用函数，然后为每个可调用对象的类型创建一个包装类，这个包装类实现了这个接口，并在虚拟调用函数中调用实际的可调用对象来实现的。

下面是一个简化的std::function的实现，它展示了类型擦除如何利用虚拟函数：

class FunctionWrapper {
public:
    virtual ~FunctionWrapper() {}
    virtual void call() = 0;
};
template <typename Callable>
class FunctionWrapperImpl : public FunctionWrapper {
public:
    FunctionWrapperImpl(Callable callable) : callable_(std::move(callable)) {}
    void call() override { callable_(); }
private:
    Callable callable_;
};
class Function {
public:
    template <typename Callable>
    Function(Callable callable)
        : wrapper_(new FunctionWrapperImpl<Callable>(std::move(callable))) {}
    void operator()() { wrapper_->call(); }
private:
    std::unique_ptr<FunctionWrapper> wrapper_;
};

在这个例子中，FunctionWrapper是一个接口，它有一个虚拟的call函数。FunctionWrapperImpl是一个模板类，它为每个可调用对象的类型创建一个实现了FunctionWrapper接口的包装类。Function类则使用一个指向FunctionWrapper的std::unique_ptr来存储这个包装类的实例，并在它的调用运算符中调用FunctionWrapper的call函数。

这样，Function就可以存储任何类型的可调用对象，并在运行时调用这个对象，而无需在编译时知道这个对象的实际类型。这就是类型擦除如何利用虚拟函数来实现的。

4.2 代码示例：结合类型擦除和虚拟函数的应用 (Code Example: Application Combining Type Erasure and Virtual Function Calls)

让我们看一个更实际的例子，这个例子展示了如何在一个事件处理系统中使用类型擦除和虚拟函数。在这个系统中，我们有一个EventHandler类，它可以处理任何类型的事件。每种类型的事件都有一个处理函数，这个处理函数在运行时被调用。

class Event {};
class EventHandlerWrapper {
public:
    virtual ~EventHandlerWrapper() {}
    virtual void handle(Event& event) = 0;
};
template <typename EventT>
class EventHandlerWrapperImpl : public EventHandlerWrapper {
public:
    EventHandlerWrapperImpl(std::function<void(EventT&)> handler)
        : handler_(std::move(handler)) {}
    void handle(Event& event) override {
        handler_(static_cast<EventT&>(event));
    }
private:
    std::function<void(EventT&)> handler_;
};
class EventHandler {
public:
    template <typename EventT>
    EventHandler(std::function<void(EventT&)> handler)
        : wrapper_(new EventHandlerWrapperImpl<EventT>(std::move(handler))) {}
    void handle(Event& event) { wrapper_->handle(event); }
private:
    std::unique_ptr<EventHandlerWrapper> wrapper_;
};

在这个例子中，EventHandlerWrapper是一个接口，它有一个虚拟的handle函数。EventHandlerWrapperImpl是一个模板类，它为每个事件类型的处理函数创建一个实现了EventHandlerWrapper接口的包装类。EventHandler类则使用一个指向EventHandlerWrapper的std::unique_ptr来存储这个包装类的实例，并在它的handle函数中调用EventHandlerWrapper的handle函数。

这样，EventHandler就可以处理任何类型的事件，并在运行时调用相应的处理函数，而无需在编译时知道这个处理函数的实际类型。这就是类型擦除和虚拟函数在实际应用中的一个例子。

第五章：类型擦除和虚拟函数调用在Qt中的应用

Qt是一个跨平台的C++图形用户界面应用程序开发框架，它广泛应用于开发GUI程序，也被广泛用于开发非GUI程序，如命令行工具和服务器。Qt的核心特性之一就是其元对象系统（Meta-Object System），它提供了信号（Signals）和槽（Slots）机制，这是一种类型安全的事件处理机制。

5.1 代码示例：Qt信号和槽机制的实现

Qt的信号和槽机制是一种事件驱动的编程模式，它允许对象之间的通信，而不需要这些对象彼此了解。这种机制的实现依赖于Qt的元对象系统，它在编译时生成额外的代码，用于处理信号和槽的连接和调用。

下面是一个简单的代码示例，演示了如何在Qt中使用信号和槽：

#include <QObject>
// 声明一个新的类，继承自QObject
class MyClass : public QObject
{
    Q_OBJECT  // 这个宏是必需的，它启用了Qt的元对象系统
public:
    MyClass(QObject* parent = nullptr) : QObject(parent) {}
    // 声明一个槽
public slots:
    void mySlot() {
        // 这个槽会在信号触发时被调用
    }
    // 声明一个信号
signals:
    void mySignal();
};
// 在某个函数中使用信号和槽
void someFunction() {
    MyClass obj;
    // 连接信号和槽
    connect(&obj, &MyClass::mySignal, &obj, &MyClass::mySlot);
    // 触发信号
    emit obj.mySignal();
}

在这个例子中，我们首先声明了一个新的类MyClass，它继承自QObject。然后，我们在这个类中声明了一个槽mySlot和一个信号mySignal。在someFunction函数中，我们创建了一个MyClass的对象obj，然后使用connect函数连接了mySignal和mySlot。最后，我们使用emit关键字触发了mySignal，这会导致mySlot被调用。

在Qt中，当一个信号被发出时，连接到它的槽通常会立即执行，就像一个普通的函数调用。当这种情况发生时，信号和槽机制完全独立于任何GUI事件循环。执行emit关键字后面的代码就像调用普通函数一样，这是因为信号实际上就是函数，它们的函数体由Qt的元对象编译器（Meta-Object Compiler，MOC）在编译时生成。信号函数的主要任务就是调用QMetaObject::activate函数，传入一个指向参数的指针数组。

// SIGNAL 0
void Counter::valueChanged(int _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

QMetaObject::activate函数会查找内部数据结构，找出连接到该信号的所有槽。对于每一个槽，都会执行以下的代码：

// Determine if this connection should be sent immediately or
// put into the event queue
if ((c->connectionType == Qt::AutoConnection && !receiverInSameThread)
 || (c->connectionType == Qt::QueuedConnection)) {
    queued_activate(sender, signal_index, c, argv, locker);
    continue;
} else if (c->connectionType == Qt::DirectConnection) {
    direct_activate(c, sender, receiver, argv, locker);
}

这段代码首先检查连接的类型。如果连接的类型是Qt::AutoConnection（这是默认的连接类型），并且接收者不在同一个线程，或者连接的类型是Qt::QueuedConnection，那么它会将槽的调用放入事件队列，稍后再执行。否则，如果连接的类型是Qt::DirectConnection，那么它会立即调用槽。

这就是Qt信号和槽机制的底层实现。在这个过程中，类型擦除和虚拟函数调用起到了关键的作用。类型擦除允许我们在运行时处理不同类型的对象，而虚拟函数调用则使得我们可以在运行时决定调用哪个函数。这两种技术都是实现信号和槽机制的基础。

5.2 类型擦除和虚拟函数调用在Qt Model/View架构中的应用

Qt包含一组使用模型/视图架构来管理数据与其呈现给用户方式之间关系的item view类。这种架构的功能分离为开发者提供了更大的灵活性，以自定义项目的呈现，并提供了一个标准的模型接口，以允许使用现有的item view来使用各种数据源。在这个架构中，模型、视图和委托通过信号和槽进行通信：

模型的信号通知视图数据源中的数据发生了变化。
视图的信号提供了用户与显示的项目交互的信息。
委托的信号在编辑期间用于告诉模型和视图编辑器的状态。

在这个过程中，类型擦除和虚拟函数调用起到了关键的作用。类型擦除允许我们在运行时处理不同类型的对象，而虚拟函数调用则使得我们可以在运行时决定调用哪个函数。这两种技术都是实现模型/视图架构的基础。

5.2.1 类型擦除在模型/视图架构中的应用

在模型/视图架构中，模型包含数据和其结构。所有的item模型都基于QAbstractItemModel类。这个类定义了一个接口，该接口被视图和委托用来访问数据。数据本身不必存储在模型中；它可以存储在数据结构或存储库中。这就是类型擦除在模型/视图架构中的应用。通过类型擦除，我们可以在运行时处理不同类型的数据源，而无需改变底层的数据结构。

5.2.2 虚拟函数调用在模型/视图架构中的应用

在模型/视图架构中，视图是项目的容器。视图可能以列表或网格的形式显示数据。在标准视图中，委托渲染数据项。当一个项目被编辑时，委托直接使用模型索引与模型进行通信。这就是虚拟函数调用在模型/视图架构中的应用。通过虚拟函数调用，我们可以在运行时决定如何渲染和编辑数据项。

在下一节中，我们将深入探讨类型擦除和虚拟函数调用的原理，并通过实际的代码示例来展示它们的

第六章：类型擦除和虚拟函数调用在音视频处理中的应用

在音视频处理中，类型擦除和虚拟函数调用的技术可以发挥重要作用。在本章中，我们将深入探讨这两种技术在音视频处理中的应用，并通过一个综合的代码示例来展示它们的作用。

6.1 音视频处理流程概述

在音视频处理中，一般会有以下几个步骤：

从音视频源获取数据
使用解码器（Decoder）将原始数据解码为可以处理的格式
对解码后的数据进行处理
使用编码器（Encoder）将处理后的数据编码为可以输出的格式
输出处理后的数据

下图展示了这个流程：

在这个流程中，类型擦除和虚拟函数调用可以在多个地方发挥作用。例如，解码器和编码器可能需要支持多种不同的编码格式，这就需要使用类型擦除和虚拟函数调用来实现多态。

6.2 使用FFmpeg和Qt实现的音视频播放器

FFmpeg是一个非常强大的音视频处理库，它支持多种音视频编码格式，并提供了一套完整的解码、编码、滤镜和混流的解决方案。Qt是一个跨平台的应用程序开发框架，它提供了一套丰富的GUI组件和多媒体处理接口。

在这个示例中，我们将使用FFmpeg和Qt来实现一个简单的音视频播放器。这个播放器将支持多种音视频编码格式，这就需要使用类型擦除和虚拟函数调用来实现多态。

// 以下代码为简化示例，可能需要根据实际情况进行调整
// 基类：解码器
class Decoder {
public:
    virtual ~Decoder() = default;
    virtual void decode(AVFrame* frame) = 0;  // 解码函数，使用虚函数实现多态
};
// 类型擦除：使用std::function实现
using DecoderFunc = std::function<void(AVFrame*)>;
class FunctionDecoder : public Decoder {
public:
    FunctionDecoder(DecoderFunc func) : func_(std::move(func)) {}
    void decode(AVFrame* frame) override {
        func_(frame);
    }
private:
    DecoderFunc func_;
};
// H.264解码函数
DecoderFunc h264DecoderFunc = [](AVFrame* frame) {
    // 使用FFmpeg的API进行解码
    // 这里仅为示例，实际使用时需要根据实际情况进行调整
    // 参考：https://natnoob.blogspot.com/2011/04/how-to-encode-and-decode-h264-by-using.html
    AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_H264);
    if (!codec) {
        throw std::runtime_error("H.264 codec not found");
    }
    AVCodecContext* context = avcodec_alloc_context3(codec);
    if (!context) {
                throw std::runtime_error("Could not allocate video codec context");
    }
    if (avcodec_open2(context, codec, nullptr) < 0) {
        throw std::runtime_error("Could not open codec");
    }
    AVPacket packet;
    av_init_packet(&packet);
    packet.data = frame->data[0];  // 这里假设frame->data[0]包含H.264编码的数据
    packet.size = frame->linesize[0];
    int ret = avcodec_send_packet(context, &packet);
    if (ret < 0) {
        throw std::runtime_error("Error sending a packet for decoding");
    }
    while (ret >= 0) {
        ret = avcodec_receive_frame(context, frame);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
            break;
        } else if (ret < 0) {
            throw std::runtime_error("Error during decoding");
        }
    }
    avcodec_close(context);
    av_free(context);
};
// 创建一个解码器
std::unique_ptr<Decoder> decoder = std::make_unique<FunctionDecoder>(h264DecoderFunc);
// 使用解码器
AVFrame* frame = ...;  // 获取一个AVFrame
decoder->decode(frame);  // 解码

在这个示例中，我们首先创建了一个解码函数h264DecoderFunc，这个函数使用FFmpeg的API来解码H.264编码的数据。然后，我们使用这个函数创建了一个FunctionDecoder对象，这个对象实现了Decoder接口，所以我们可以使用类型擦除和虚拟函数调用的技术来处理它。最后，我们使用这个解码器来解码一个AVFrame。

这个示例展示了如何使用类型擦除和虚拟函数调用的技术来实现多态。通过这种方式，我们可以轻松地切换不同的解码器，而不需要修改使用解码器的代码。这使得我们的代码更加灵活和可扩展。

在实际使用中，你可能需要根据实际情况对这个示例进行调整。例如，你可能需要处理解码错误，或者使用更复杂的解码参数。你可以参考这篇文章来获取更多关于如何使用FFmpeg进行H.264解码的信息。

结语

在我们的编程学习之旅中，理解是我们迈向更高层次的重要一步。然而，掌握新技能、新理念，始终需要时间和坚持。从心理学的角度看，学习往往伴随着不断的试错和调整，这就像是我们的大脑在逐渐优化其解决问题的“算法”。

这就是为什么当我们遇到错误，我们应该将其视为学习和进步的机会，而不仅仅是困扰。通过理解和解决这些问题，我们不仅可以修复当前的代码，更可以提升我们的编程能力，防止在未来的项目中犯相同的错误。

我鼓励大家积极参与进来，不断提升自己的编程技术。无论你是初学者还是有经验的开发者，我希望我的博客能对你的学习之路有所帮助。如果你觉得这篇文章有用，不妨点击收藏，或者留下你的评论分享你的见解和经验，也欢迎你对我博客的内容提出建议和问题。每一次的点赞、评论、分享和关注都是对我的最大支持，也是对我持续分享和创作的动力。

【C++ 多态】了解 C++ 中的类型擦除和虚拟函数调用

第一章类型擦除（Type Erasure）

1.1 类型擦除的定义

第二章类型擦除(Type Erasure)

2.1 设计意图

2.2 使用场景

2.3 底层原理

2.4 实际案例

2.4.1 案例背景

2.4.2 使用模板实现多态

2.4.3 使用类型擦除实现多态

第三章：虚拟函数调用 (Virtual Function Invocation)

3.1 设计意图 (Design Intent)

3.2 使用场景 (Use Cases)

3.3 底层原理 (Underlying Principles)

3.4 代码示例：使用虚拟函数实现多态

3.5 代码示例：虚拟函数与动态绑定

第四章：类型擦除与虚拟函数调用的交互 (Interaction between Type Erasure and Virtual Function Calls)

4.1 类型擦除如何利用虚拟函数 (How Type Erasure Utilizes Virtual Function Calls)

4.2 代码示例：结合类型擦除和虚拟函数的应用 (Code Example: Application Combining Type Erasure and Virtual Function Calls)

第五章：类型擦除和虚拟函数调用在Qt中的应用

5.1 代码示例：Qt信号和槽机制的实现

5.2 类型擦除和虚拟函数调用在Qt Model/View架构中的应用

5.2.1 类型擦除在模型/视图架构中的应用

5.2.2 虚拟函数调用在模型/视图架构中的应用

第六章：类型擦除和虚拟函数调用在音视频处理中的应用

6.1 音视频处理流程概述

6.2 使用FFmpeg和Qt实现的音视频播放器

结语

热门文章

最新文章

相关课程

相关电子书

相关实验场景

【C++ 多态 】了解 C++ 中的类型擦除和虚拟函数调用

第一章 类型擦除（Type Erasure）

1.1 类型擦除的定义

第二章 类型擦除(Type Erasure)

2.1 设计意图

2.2 使用场景

2.3 底层原理

2.4 实际案例

2.4.1 案例背景

2.4.2 使用模板实现多态

2.4.3 使用类型擦除实现多态

第三章：虚拟函数调用 (Virtual Function Invocation)

3.1 设计意图 (Design Intent)

3.2 使用场景 (Use Cases)

3.3 底层原理 (Underlying Principles)

3.4 代码示例：使用虚拟函数实现多态

3.5 代码示例：虚拟函数与动态绑定

第四章： 类型擦除与虚拟函数调用的交互 (Interaction between Type Erasure and Virtual Function Calls)

4.1 类型擦除如何利用虚拟函数 (How Type Erasure Utilizes Virtual Function Calls)

4.2 代码示例：结合类型擦除和虚拟函数的应用 (Code Example: Application Combining Type Erasure and Virtual Function Calls)

第五章：类型擦除和虚拟函数调用在Qt中的应用

5.1 代码示例：Qt信号和槽机制的实现

5.2 类型擦除和虚拟函数调用在Qt Model/View架构中的应用

5.2.1 类型擦除在模型/视图架构中的应用

5.2.2 虚拟函数调用在模型/视图架构中的应用

第六章：类型擦除和虚拟函数调用在音视频处理中的应用

6.1 音视频处理流程概述

6.2 使用FFmpeg和Qt实现的音视频播放器

结语

热门文章

最新文章

相关课程

相关电子书

相关实验场景

【C++ 多态】了解 C++ 中的类型擦除和虚拟函数调用

第一章类型擦除（Type Erasure）

第二章类型擦除(Type Erasure)

第四章：类型擦除与虚拟函数调用的交互 (Interaction between Type Erasure and Virtual Function Calls)