C++ Type Erasure：实现类型擦除的多态，避免虚函数开销

好的，各位观众老爷，咱们今天来聊聊C++里一个听起来玄乎，用起来贼爽的玩意儿：类型擦除 (Type Erasure)。

啥？类型擦除？听着像科幻电影里的技术？别怕，其实它就是个让你的C++代码更灵活、更高效的小技巧。简单来说，类型擦除就是一种让你在运行时使用多态，但又避免虚函数调用开销的魔法。

为啥我们需要类型擦除？

在C++里，实现多态最常用的手段就是虚函数。虚函数很强大，但也有它的缺点：

虚函数表 (vtable) 开销： 每个包含虚函数的类都要维护一个vtable，对象里也要保存一个指向vtable的指针 (vptr)。这会增加内存占用。
虚函数调用开销： 虚函数调用需要在运行时查vtable才能确定调用哪个函数，这比直接调用函数要慢。

在某些性能敏感的场景下，这些开销就不能忍了。这时候，类型擦除就派上用场了。

类型擦除的原理：

类型擦除的核心思想是：把类型信息“擦除”掉，然后用一个通用的接口来操作不同类型的对象。听起来有点抽象，咱们用一个例子来说明。

假设我们想实现一个可以存储任何类型对象的容器，并且可以对容器里的对象进行拷贝、移动、比较等操作。如果用虚函数来实现，可能会是这样：

class AnyBase {
public:
    virtual ~AnyBase() = default;
    virtual AnyBase* clone() const = 0;
    virtual void print() const = 0;
    virtual bool equals(const AnyBase* other) const = 0;
};

template <typename T>
class Any : public AnyBase {
public:
    Any(const T& value) : data_(value) {}
    Any(T&& value) : data_(std::move(value)) {}

    AnyBase* clone() const override {
        return new Any<T>(data_);
    }

    void print() const override {
        std::cout << data_ << std::endl;
    }

    bool equals(const AnyBase* other) const override {
        if (const Any<T>* derived = dynamic_cast<const Any<T>*>(other)) {
            return data_ == derived->data_;
        }
        return false;
    }

private:
    T data_;
};

int main() {
    AnyBase* a = new Any<int>(10);
    AnyBase* b = a->clone();
    a->print(); // 输出 10
    b->print(); // 输出 10
    std::cout << a->equals(b) << std::endl; // 输出 1

    delete a;
    delete b;
    return 0;
}

这个方案虽然能工作，但问题也很明显：我们需要定义一个基类 AnyBase，并且为每个支持的类型都创建一个派生类 Any<T>。每次调用虚函数都得经过 vtable 查找，效率不高。

那么，类型擦除是怎么做的呢？

定义一个接口 (Interface)： 这个接口定义了我们想要支持的操作，比如拷贝、移动、比较等。
实现一个概念 (Concept)： 这个概念定义了类型需要满足的条件，才能被类型擦除后的对象所接受。
创建一个类型持有者 (Type Holder)： 这个类负责存储实际的对象，并实现接口中的操作。
实现类型擦除的类 (Type Erasure Class)： 这个类是用户使用的主要接口，它内部持有一个类型持有者的指针，并将用户的调用转发给类型持有者。

一个简单的类型擦除示例：

咱们来实现一个简单的 Any 类，它可以存储任何可拷贝的类型，并且提供 get() 方法来获取存储的值。

#include <iostream>
#include <memory>
#include <type_traits>

// 1. 定义接口 (Interface)
class AnyConcept {
public:
    virtual ~AnyConcept() = default;
    virtual AnyConcept* clone() const = 0;
    virtual void* data() = 0; // 返回原始数据的指针
    virtual const std::type_info& type() const = 0; // 返回原始数据的type_info
};

// 2. 实现类型持有者 (Type Holder)
template <typename T>
class AnyModel : public AnyConcept {
public:
    AnyModel(const T& value) : data_(value) {}
    AnyModel(T&& value) : data_(std::move(value)) {}

    AnyConcept* clone() const override {
        return new AnyModel<T>(data_);
    }

    void* data() override {
        return &data_;
    }

    const std::type_info& type() const override {
        return typeid(T);
    }

private:
    T data_;
};

// 3. 实现类型擦除的类 (Type Erasure Class)
class Any {
public:
    Any() : concept_(nullptr) {}

    template <typename T, typename = std::enable_if_t<!std::is_same_v<std::decay_t<T>, Any>>>
    Any(T&& value) : concept_(new AnyModel<std::decay_t<T>>(std::forward<T>(value))) {}

    Any(const Any& other) : concept_(other.concept_ ? other.concept_->clone() : nullptr) {}

    Any(Any&& other) noexcept : concept_(other.concept_) {
        other.concept_ = nullptr;
    }

    ~Any() {
        delete concept_;
    }

    Any& operator=(const Any& other) {
        Any temp(other);
        std::swap(concept_, temp.concept_);
        return *this;
    }

    Any& operator=(Any&& other) noexcept {
        std::swap(concept_, other.concept_);
        return *this;
    }

    template <typename T>
    T* get_if() {
        if (concept_ && concept_->type() == typeid(T)) {
            return static_cast<T*>(concept_->data());
        }
        return nullptr;
    }

    bool has_value() const {
        return concept_ != nullptr;
    }

    const std::type_info& type() const {
      if (concept_){
        return concept_->type();
      }
      else {
        return typeid(void);
      }
    }

private:
    AnyConcept* concept_;
};

int main() {
    Any a = 10;
    Any b = std::string("hello");
    Any c = a;

    int* a_ptr = a.get_if<int>();
    std::string* b_ptr = b.get_if<std::string>();

    if (a_ptr) {
        std::cout << "a: " << *a_ptr << std::endl; // 输出 a: 10
    }

    if (b_ptr) {
        std::cout << "b: " << *b_ptr << std::endl; // 输出 b: hello
    }
    if (c.has_value()){
      std::cout << "c type: " << c.type().name() << std::endl; // 输出 c type: i
    }

    return 0;
}

代码解释：

AnyConcept 是接口，定义了 clone()、data()和type() 方法。
AnyModel<T> 是类型持有者，它存储了实际的 T 类型对象，并实现了 AnyConcept 接口。
Any 是类型擦除的类，它内部持有一个 AnyConcept 的指针。它的构造函数接受任何类型 T 的对象，并创建一个 AnyModel<T> 对象来存储它。get_if<T>() 方法可以用来安全地获取存储的值，如果类型不匹配，则返回 nullptr。
通过type()方法可以获取到存储的类型信息
通过has_value()方法可以判断是否存储有值

类型擦除的优势：

避免虚函数开销： 类型擦除使用模板和静态分发，避免了虚函数调用和 vtable 的开销。
灵活性： 可以存储任何满足特定概念的类型，无需继承自特定的基类。
编译时类型检查： 可以在编译时检查类型是否满足概念的要求。

类型擦除的劣势：

代码复杂度： 类型擦除的代码实现比较复杂，需要仔细设计接口和类型持有者。
编译时间： 模板代码可能会增加编译时间。
运行时类型信息有限： 虽然可以通过 typeid 获取类型信息，但通常不如虚函数那样灵活。

类型擦除的应用场景：

实现通用的容器： 比如 boost::any 和 std::any。
实现类型安全的事件系统： 可以存储任何可调用的对象，并在事件发生时调用它们。
实现策略模式： 可以动态地选择不同的算法，而无需使用虚函数。
函数对象 (Functors)： 可以存储任何可调用的对象，比如函数指针、lambda 表达式、函数对象等。

类型擦除的进阶技巧：

完美转发 (Perfect Forwarding)： 使用 std::forward 可以完美地转发参数，避免不必要的拷贝。
SFINAE (Substitution Failure Is Not An Error)： 使用 SFINAE 可以根据类型的特性来选择不同的实现。
Concept： 使用 C++20 的 Concept 可以更清晰地定义类型的要求。

类型擦除 vs 虚函数：

特性	类型擦除	虚函数
性能	更高，避免虚函数调用开销	较低，需要查 vtable
灵活性	更高，可以存储任何满足概念的类型	较低，需要继承自基类
类型检查	编译时类型检查	运行时类型检查
代码复杂度	更高，实现比较复杂	较低，实现比较简单
运行时类型信息	有限，只能获取类型信息，不能动态调用函数	丰富，可以动态调用虚函数

总结：

类型擦除是一种强大的C++技术，可以让你在运行时使用多态，但又避免虚函数调用开销。它适用于性能敏感的场景，并且可以提高代码的灵活性。但是，类型擦除的代码实现比较复杂，需要仔细设计。

希望今天的讲座能让你对类型擦除有一个更清晰的认识。记住，类型擦除不是万能的，要根据实际情况选择合适的方案。

练习题：

尝试扩展上面的 Any 类，增加 move() 方法来移动存储的值。
使用类型擦除实现一个通用的事件系统，可以存储任何可调用的对象，并在事件发生时调用它们。
研究 std::function 的实现，了解它是如何使用类型擦除来存储任何可调用的对象的。

好了，各位，今天的课就上到这里，下课！

发表回复 取消回复

发表回复取消回复