C++ 类型擦除详解
类型擦除让 C++ 处理运行时未知类型。核心：隐藏具体类型，只暴露接口。标准库如 std::function, std::any, std::variant 都依赖它。
类型擦除是什么？
定义：运行时统一处理多种类型，编译时忘掉具体类型。只剩接口。
解决痛点：
- 模板太静态，无法动态类型（插件、网络数据）。
- 容器存异构类型。
- API 解耦：接受任意 callable。
核心机制：动态多态 + vtable。
实现原理
三件套：
- 接口：纯虚基类。
- Holder：模板派生，持值。
- 包装器：持
Base*，转发调用。
vs 模板：运行时开销（虚调用、heap），但灵活。
vs variant：variant 是静态类型擦除，编译期已知所有类型，无 heap 分配。
标准库示例
std::any (C++17)
简化实现（核心：vtable 类型擦除）：
// 简化版 std::any：使用 vtable 实现类型擦除
class Any {
// VTable: 存储类型相关的操作函数指针
struct VTable {
void* (*clone)(const void*); // 拷贝函数：深拷贝对象
void (*destroy)(void*); // 析构函数：释放对象
const std::type_info& (*type)(); // 类型信息函数：获取类型ID
};
void* ptr_; // 指向堆上存储的实际对象
const VTable* vt_; // 指向类型对应的 vtable
public:
// 构造函数：接受任意类型，完美转发到堆上
template<typename T>
Any(T&& val) : ptr_(new T(std::forward<T>(val))),
vt_(get_vtable<T>()) {}
// 类型安全的转换：运行时检查类型是否匹配
template<typename T>
T* cast() {
if (vt_->type() != typeid(T)) throw std::bad_any_cast{};
return static_cast<T*>(ptr_);
}
// 析构：通过 vtable 调用正确的析构函数
~Any() { vt_->destroy(ptr_); }
};std::function (C++11)
统一 callable，核心：类型擦除 + vtable + SBO。
核心思想
问题：如何用一个类型存储任意 callable（lambda、函数指针、函数对象）？
答案：类型擦除 + 虚函数表（vtable）
┌─────────────────────────────────────────────────────────────┐
│ std::function<int(int)> f │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ vtable* ──→ [destroy][clone][call] │ │
│ │ storage ──→ 实际的 callable（类型已擦除） │ │
│ └─────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘关键概念：
vtable（虚函数表）：存储类型相关的操作函数指针
- 每种 callable 类型对应一个 vtable
- 编译期生成，运行时查找
SBO（Small Buffer Optimization）：小对象优化
- 小对象（≤32字节）直接存在栈上，避免堆分配
- 大对象才分配到堆上
类型擦除：通过
void*或 char 数组存储，忘记具体类型
完整实现（带详细注释）
// 简化版 std::function：类型擦除 + 小对象优化(SBO)
template<typename Ret, typename... Args>
class Function {
// === 第一步：定义 vtable（虚函数表） ===
// vtable 存储类型相关的操作函数指针，每种 callable 类型对应一个 vtable
struct VTable {
void (*destroy)(void*); // 析构函数：释放 callable
void (*clone)(const void*, void*); // 拷贝函数：复制 callable
Ret (*call)(void*, Args...); // 调用函数：执行 callable
};
// === 第二步：定义存储空间 ===
// SBO: Small Buffer Optimization - 小对象优化
// 小对象(≤32字节)直接存储在栈上，避免堆分配开销
alignas(16) char buf_[32]; // 对齐到16字节，满足大多数类型的对齐要求
void* ptr_ = nullptr; // 大对象时使用：指向堆上存储的 callable
const VTable* vt_ = nullptr; // 指向类型对应的 vtable
// 编译期判断：类型F是否可以用SBO
template<typename F>
static constexpr bool CanSBO = sizeof(F) <= 32;
// === 第三步：为每种 callable 类型生成对应的 vtable ===
template<typename F>
static const VTable* get_vtable() {
static const VTable vt = {
// destroy: 调用 F 的析构函数
[](void* p) { static_cast<F*>(p)->~F(); },
// clone: 拷贝构造 F
[](const void* src, void* dst) {
new(dst) F(*static_cast<const F*>(src));
},
// call: 调用 F 的 operator()
[](void* p, Args... args) -> Ret {
return (*static_cast<F*>(p))(std::forward<Args>(args)...);
}
};
return &vt;
}
public:
// === 第四步：构造函数 - 接受任意 callable ===
template<typename F>
Function(F&& f) {
vt_ = get_vtable<F>(); // 获取类型对应的 vtable
if constexpr (CanSBO<F>) {
// SBO: 小对象直接在 buf_ 上构造，placement new
// 避免堆分配，提升性能
new(buf_) F(std::forward<F>(f));
} else {
// 大对象：分配到堆上
ptr_ = new F(std::forward<F>(f));
}
}
// === 第五步：调用操作符 - 通过 vtable 转发 ===
Ret operator()(Args... args) {
// ptr_ 非空则用 ptr_（堆上），否则用 buf_（栈上）
void* storage = ptr_ ? ptr_ : buf_;
return vt_->call(storage, std::forward<Args>(args)...);
}
// === 第六步：析构 - 根据存储位置调用正确的析构 ===
~Function() {
void* storage = ptr_ ? ptr_ : buf_;
vt_->destroy(storage);
// 如果是堆分配，需要释放内存
if (ptr_) {
delete static_cast<char*>(ptr_);
}
}
};工作流程图解
构造阶段：
┌─────────────────────────────────────────────────────────────┐
│ Function<int(int)> f = [](int x) { return x * x; }; │
│ │
│ 1. lambda 类型推断 → LambdaType │
│ 2. get_vtable<LambdaType>() → 生成 vtable │
│ ┌─────────────────────────────────────┐ │
│ │ destroy: LambdaType::~LambdaType │ │
│ │ clone: LambdaType 的拷贝构造 │ │
│ │ call: LambdaType::operator() │ │
│ └─────────────────────────────────────┘ │
│ 3. sizeof(LambdaType) ≤ 32? → 是 → SBO │
│ 4. new(buf_) LambdaType(...) → 存储在栈上 │
└─────────────────────────────────────────────────────────────┘
调用阶段：
┌─────────────────────────────────────────────────────────────┐
│ f(5) │
│ │
│ 1. 判断存储位置 → buf_（SBO） │
│ 2. vt_->call(buf_, 5) → 虚函数调用 │
│ 3. 执行 lambda → return 25 │
└─────────────────────────────────────────────────────────────┘使用示例
// 示例1：存储 lambda
Function<int(int)> f = [](int x) { return x * x; };
std::cout << f(5); // 输出: 25
// 示例2：存储函数指针
int add(int a, int b) { return a + b; }
Function<int(int, int)> g = add;
std::cout << g(3, 4); // 输出: 7
// 示例3：存储 std::bind 结果
Function<void()> h = std::bind([](int a, int b) {
std::cout << a + b << std::endl;
}, 3, 4);
h(); // 输出: 7
// 示例4：存储带捕获的 lambda（SBO）
int multiplier = 10;
Function<int(int)> square = [multiplier](int x) {
return x * x * multiplier;
};
std::cout << square(3); // 输出: 90
// 示例5：存储大对象（非 SBO，堆分配）
struct BigCallable {
std::array<int, 100> data_; // 400 字节，超过 SBO 阈值
int operator()(int x) { return data_[0] + x; }
};
Function<int(int)> big = BigCallable{};性能对比
| 场景 | SBO（小对象） | 非SBO（大对象） |
|---|---|---|
| 构造 | 栈上 placement new | 堆分配 + 构造 |
| 调用 | 虚函数调用 | 虚函数调用 |
| 析构 | 直接调用析构 | 析构 + 堆释放 |
| 内存开销 | 32字节栈空间 | 堆内存 + 指针 |
关键设计总结：
- vtable：编译期生成，运行时查找，实现类型擦除
- SBO：小对象优化，避免堆分配，提升性能
- 存储策略：
CanSBO<T>编译期判断，自动选择最优存储方式
手动实现 Any（经典模式）
// 手动实现 Any：经典类型擦除模式（虚函数版）
class Any {
// === 1. 接口层：纯虚基类，定义统一操作接口 ===
struct Concept {
virtual ~Concept() = default;
virtual Concept* clone() const = 0; // 虚拷贝，支持 Any 的拷贝构造
};
// === 2. Holder 层：模板派生类，持有具体类型 ===
template<typename T>
struct Holder : Concept {
T val_; // 实际存储的值
// 构造函数：完美转发初始化值
Holder(T&& v) : val_(std::forward<T>(v)) {}
// 虚拷贝实现：创建新的 Holder 副本
Concept* clone() const override {
return new Holder(T{val_}); // 拷贝构造 T
}
};
// === 3. 包装器层：管理 Concept 指针，对外提供统一接口 ===
std::unique_ptr<Concept> ptr_; // 用智能指针管理生命周期
public:
// 万能构造函数：接受任意类型 T
template<typename T>
Any(T&& v) : ptr_(new Holder<T>(std::forward<T>(v))) {}
// 获取存储的值：运行时类型检查
template<typename T>
T& get() {
// dynamic_cast 进行安全的向下转型
auto* h = dynamic_cast<Holder<T>*>(ptr_.get());
if (!h) throw std::bad_cast{}; // 类型不匹配
return h->val_; // 返回实际值的引用
}
};
// ===== 使用示例 =====
Any a = 42; // 存储 int
Any b = std::string("hello"); // 存储 string
Any c = a; // 拷贝构造（通过虚 clone()）
std::cout << a.get<int>(); // 输出: 42
std::cout << b.get<std::string>(); // 输出: hello
// std::cout << a.get<std::string>(); // 运行时抛出 std::bad_cast优缺点
| 优点 | 缺点 |
|---|---|
| 运行时灵活（插件、事件） | 性能损失：虚调用 + heap |
| 统一接口，少模板代码 | 调试难：类型隐藏 |
| 内存占用大 |
何时用：真有动态需求。优先用模板/variant。
总结
- 类型擦除 = 虚函数 + 模板桥接
- 标准库实现：vtable + SBO 优化
- 能用模板/variant 就别用擦除
Related Articles
2025-08-17
C++ RTTI
下面把 C++ 的 RTTI（Run-Time Type Information，运行时类型信息）系统一次讲清楚，覆盖原理、用法、细节与坑，并给出精简示例。内容“精准”，不绕弯。 1. 什么是 RTTI RTTI 是编译器在多态场景下，为对象保留其动态类型信息，以便在运行时查询和安全转换。标准接口主要有两件事： typeid：拿到对象（或类型）的类型描述 std::type_info。 dynamic_cast：做安全的向下转型（downcast）/交叉转型（cross-cast）。 触发条件：多态类（类里至少有一个 virtual 函数）。非多态类也能用 typeid(T) 或对非多态表达式用 typeid(expr)（这时只给静态类型）。 2. 两个核心工具 1. typeid 语义： typeid(T)：返回编译期类型 T 的 type_info（无运行期开销）。 typeid(expr)： 若 expr 是多态类型的左值/泛左值，结果是动态类型。 否则结果是静态类型，不求值 expr（无副作用）。 返回 const std::type_in...
2025-11-04
C++ std::print
1. 概述 C++23 引入了 std::print 和 std::println，这是现代 C++ 对格式化输出的重大改进。相比传统的 printf，这些新函数提供了类型安全、性能优异且易于使用的格式化输出方案。 2. 基本用法 简单输出 #include <print> int main() { // 基本输出 std::print("Hello, World!\n"); // 带换行的输出 std::println("Hello, World!"); return 0; } 格式化输出 #include <print> #include <string> int main() { int age = 25; std::string name = "Alice"; // 格式化输出 std::print("Name: {}, Age: {}\n", name, age); ...
2023-06-27
Useful Boost Libraries
基于 boost 1.82… timer 计时器 过去老的 boost/timer.hpp 已经废弃了，目前推荐使用的是 boost/timer/timer.hpp, 主要包括下面了2个类 class detail boost::timer::cpu_timer 计时器 boost::timer::auto_cpu_timer 计时器，基于cpu_timer实现，在析构的时候输出耗时 struct cpu_times { nanosecond_type wall; // 挂钟时间 nanosecond_type user; // 用户时间 nanosecond_type system; // 系统时间 void clear() {wall = user = system = 0LL; } }; 默认的输出格式为下： “%w s wall, %u s user + %s s system = %t s CPU (%p%)\n” format meaning ...
2025-08-02
C++ move_only_function
在C++中，std::move_only_function 是C++23引入的标准库功能，用于表示仅支持移动语义的函数对象（callable object）。它是std::function的变种，但与std::function不同的是，std::move_only_function不要求存储的函数对象是可拷贝的，仅要求可移动，从而支持更广泛的用例，例如存储只支持移动语义的对象（如std::unique_ptr或lambda表达式中的非可拷贝对象）。以下是对std::move_only_function的详细说明，包括其设计、用法、实现规则和注意事项。 1. 什么是 std::move_only_function？ std::move_only_function 是一个类模板，定义在 <functional> 头文件中，用于包装可调用对象（如函数指针、lambda表达式、仿函数等），并提供类型擦除（type erasure），使其可以存储不同类型的可调用对象，同时只要求这些对象支持移动构造和移动赋值，而不需要支持拷贝。它是C++23标准的一部分，旨在解决std::fun...
2025-01-25
C++ Alignment
内存对齐不是什么花里胡哨的理论玩意儿，它是硬件决定的铁律。忽略它，你的代码要么崩溃，要么性能烂到家。现代C++给了你工具，让你精确控制对齐，而不是祈祷编译器聪明。 1. 为什么对齐重要？ 硬件要求：CPU从内存读取数据必须按特定边界（如4字节、8字节、16字节）。不对齐，访问非法，段错误伺候。 性能杀手：不对齐导致多次内存访问、缓存失效。SIMD指令（SSE/AVX）强制16/32字节对齐，否则零矢量惩罚。 缓存线：现代CPU缓存64字节。不对齐跨缓存线，延迟翻倍。 记住：对齐是优化，不是可选。过度对齐浪费空间，但不足齐更糟。 2. alignof：查询对齐需求 alignof(T) 返回类型T的最小对齐字节数。简单、直观。 #include <print> int main() { std::print("alignof(char): {}\n", alignof(char)); std::print("alignof(int): {}\n", alignof(int)); std::prin...
2023-01-16
Cpp Callable Objects
在 C++ 中，Callable Object（可调用对象） 指的是任何可以像函数一样被调用的事物。简单来说，就是任何可以使用 () 运算符（Function Call Operator）的对象。 在现代 C++（C++11 及以后）中，可调用对象的概念非常重要，因为它是 STL 算法、线程（std::thread）以及回调机制的核心。 C++ 中的可调用对象主要分为以下 5 类。 1. 普通函数与函数指针 (Function Pointers) 这是最基础的形式，继承自 C 语言。 特点： 没有状态（Stateless），行为固定。 适用场景： 简单的回调，也就是所谓的 C 风格 API。 #include <print> void hello() { std::println("Hello from Function Pointer!"); } int main() { // 定义函数指针 void (*funcPtr)() = &hello; // & 是可选的 // 调...