类型擦除（Type Erasure） on Dorkytiger 的小屋

Type Erasure 要解决什么问题

Mon, 01 Jan 0001 00:00:00 +0000

一、问题场景

场景：你有一个容器，想存"满足某个接口的任何类型"，但又不希望用户继承你的基类。

传统做法是定义一个抽象基类，用户必须继承它：

class Drawable {
public:
    virtual void draw() const = 0;
    virtual ~Drawable() = default;
};

// 用户必须继承 Drawable
class MyCircle : public Drawable { ... };

问题：用户需要用 public 继承你的类，这是侵入式的。用户可能已经有了自己的类层次，不想再改继承。

Type Erasure 的做法：非侵入式——用户不需要继承任何东西。你提供包装器。

二、Type Erasure 的核心模式

Type Erasure 的经典实现是 外部多态（External Polymorphism）：

// 1. 用 concept 定义接口
template <typename T>
concept Drawable = requires(const T& t) {
    { t.draw() } -> std::same_as<void>;
};

// 2. 类型擦除包装器（用户可以传入任何满足 Drawable 的类型）
class DrawableWrapper {
    struct Concept {
        virtual void draw() const = 0;
        virtual ~Concept() = default;
    };

    template <Drawable T>
    struct Model : Concept {
        T obj_;
        Model(T obj) : obj_(std::move(obj)) {}
        void draw() const override { obj_.draw(); }
    };

    std::unique_ptr<Concept> pimpl_;

public:
    template <Drawable T>
    DrawableWrapper(T obj) : pimpl_(std::make_unique<Model<T>>(std::move(obj))) {}

    void draw() const { pimpl_->draw(); }
};

用法：

`std::function` 的底层——Type Erasure 的典型实现

Mon, 01 Jan 0001 00:00:00 +0000

一、`std::function` 是怎么存任意可调用对象的？

std::function<int(int, int)> f = [](int a, int b) { return a + b; };
int result = f(3, 4);  // 7

你传进去的是一个 lambda（每 lambda 类型不同），但 f 能统一调用。这靠的就是 Type Erasure。

二、小对象优化（SBO）

std::function 内部有一个小缓冲区（通常是 16-32 字节）：

如果可调用对象 ≤ SBO 阈值：
  ┌─────────────────────────────────┐
  │ vptr  │ 小缓冲区（存 lambda）    │  ← 栈上，无堆分配
  └─────────────────────────────────┘

如果可调用对象 > SBO 阈值：
  ┌─────────────────────────────────┐
  │ vptr  │  ptr → 堆上的 lambda    │  ← 一次堆分配
  └─────────────────────────────────┘

实测：

// 小 lambda（捕获 2 个 int，16 字节）→ SBO，无堆分配
int a = 1, b = 2;
auto small = [a, b](int x) { return a + b + x; };

// 大 lambda（捕获一个大 vector）→ 堆分配
vector<int> v(1000);
auto big = [v](int x) { return v.size() + x; };

面试题：“为什么高频构造 std::function 性能差？”

Type Erasure 的实战场景

Mon, 01 Jan 0001 00:00:00 +0000

一、插件系统

你写了一个事件处理系统，允许用户注册回调处理事件。你不想强制用户继承 EventHandler 接口：

class EventBus {
    std::vector<std::function<void(const Event&)>> handlers_;
public:
    void register(std::function<void(const Event&)> handler) {
        handlers_.push_back(std::move(handler));
    }

    void fire(const Event& evt) {
        for (auto& h : handlers_) h(evt);
    }
};

// 用户不需要继承任何东西，传个 lambda 就行
EventBus bus;
bus.register([](const Event& e) { /* 处理 */ });

二、什么时候用 Type Erasure，什么时候用 variant？

如果你在编译期知道所有可能的类型：
  用 std::variant<Circle, Square>  ← 更快，没有虚函数调用

如果你要在运行时支持任意新类型：
  用 Type Erasure  ← 灵活，但有一次虚函数调用

如果你要让用户不需要改继承关系：
  用 Type Erasure  ← 非侵入式

类型擦除（Type Erasure） on Dorkytiger 的小屋

Type Erasure 要解决什么问题

一、问题场景

二、Type Erasure 的核心模式

`std::function` 的底层——Type Erasure 的典型实现

一、std::function 是怎么存任意可调用对象的？

二、小对象优化（SBO）

Type Erasure 的实战场景

一、插件系统

二、什么时候用 Type Erasure，什么时候用 variant？

一、`std::function` 是怎么存任意可调用对象的？