类型萃取（Type Traits）：编译期的“类型侦探”

类型萃取，英文叫 Type Traits。我第一次听到这个词时，觉得挺玄乎的。说白了，它就是在编译期问编译器：“嘿，这个类型是不是 int？”或者“这个类型有没有 const 修饰？”

你想想看，我们写模板时，经常需要根据类型的不同，做不同的事情。比如，如果传进来的是 int，我就做加法；如果是 string，我就做拼接。这在运行时很容易，用 if 判断就行。但在编译期，模板实例化时，类型就已经确定了。这时候，就需要类型萃取来帮我们做“编译期的判断”。

标准库中的“老熟人”：is_same

先看一个最简单的例子：std::is_same。它问的就是“两个类型是否相同”。

#include <type_traits>
#include <iostream>

int main() {
    std::cout << std::is_same<int, int>::value << std::endl;   // 1 (true)
    std::cout << std::is_same<int, const int>::value << std::endl; // 0 (false)
    std::cout << std::is_same<int, int&>::value << std::endl;  // 0 (false)
    return 0;
}

输出结果：1, 0, 0。注意，int 和 const int 在 is_same 眼里是不同的。这很合理，因为加了 const 就是不同的类型了。

我个人习惯在写 SFINAE（替换失败不是错误）时，大量使用 is_same。比如，我只想让某个函数模板接受 int 或 double：

template <typename T>
typename std::enable_if<
    std::is_same<T, int>::value || std::is_same<T, double>::value,
    void
>::type process(T value) {
    std::cout << "Processing numeric: " << value << std::endl;
}

这里 enable_if 配合 is_same，实现了“只有 int 或 double 才能调用”的效果。我在项目中遇到过类似的需求：一个序列化函数，只允许对 POD 类型（简单旧数据）进行二进制序列化。用 is_same 配合 is_pod，几行代码就搞定了。

remove_reference：去掉“引用”的伪装

另一个常用的 traits 是 std::remove_reference。它能把 int& 变成 int，把 int&& 也变成 int。

#include <type_traits>

int main() {
    // 去掉引用后，类型都变成 int
    using T1 = std::remove_reference<int&>::type;   // int
    using T2 = std::remove_reference<int&&>::type;  // int
    using T3 = std::remove_reference<int>::type;     // int (本身就不是引用)
    return 0;
}

为什么要去掉引用？嗯，这里有个坑。我在写转发函数（perfect forwarding）时，经常需要知道“去掉引用后，这个类型到底是什么”。比如，decltype 推导出的类型可能带有引用，但我想比较的是原始类型。这时候 remove_reference 就派上用场了。

标准库中其他常见的 traits

标准库提供了几十个 traits，我挑几个最常用的列出来：

Traits 名称	作用	示例
is_pointer	判断是否为指针类型	is_pointer<int*>::value == true
is_const	判断是否有 const 修饰	is_const<const int>::value == true
is_arithmetic	判断是否为算术类型（int, float 等）	is_arithmetic<double>::value == true
remove_const	去掉 const 修饰	remove_const<const int>::type == int
add_pointer	添加指针修饰	add_pointer<int>::type == int*
decay	模拟函数参数传递时的类型退化	decay<int[3]>::type == int*

这些 traits 就像工具箱里的螺丝刀，每个都有特定的用途。我个人最常用的是 decay，因为它能同时处理数组到指针的退化、函数到函数指针的退化，以及去掉顶层 const/引用。在写泛型代码时，decay 能帮你把类型“归一化”，方便后续比较。

自定义 traits：自己动手，丰衣足食

标准库的 traits 虽然多，但总有不够用的时候。比如，我想判断一个类型是不是“智能指针”。标准库没有提供这个 traits，那就自己写一个。

#include <type_traits>
#include <memory>

// 主模板：默认不是智能指针
template <typename T>
struct is_smart_pointer : std::false_type {};

// 特化：std::shared_ptr
template <typename T>
struct is_smart_pointer<std::shared_ptr<T>> : std::true_type {};

// 特化：std::unique_ptr
template <typename T, typename D>
struct is_smart_pointer<std::unique_ptr<T, D>> : std::true_type {};

// 特化：std::weak_ptr
template <typename T>
struct is_smart_pointer<std::weak_ptr<T>> : std::true_type {};

// 使用
static_assert(is_smart_pointer<std::shared_ptr<int>>::value, "Should be smart pointer");
static_assert(!is_smart_pointer<int*>::value, "Raw pointer is not smart");

这里用到了模板特化。主模板继承 std::false_type，表示“默认不是”。然后对三种智能指针分别做特化，继承 std::true_type。这样，is_smart_pointer<T>::value 就能在编译期给出正确答案。

更高级的自定义：带条件的 traits

有时候，我们需要 traits 能根据类型的某些属性做判断。比如，判断一个类型是否“可哈希”（即能用 std::hash 计算哈希值）。

#include <type_traits>
#include <functional>

// 检测是否有 std::hash 特化
template <typename T, typename = void>
struct is_hashable : std::false_type {};

template <typename T>
struct is_hashable<T, 
    std::void_t<decltype(std::hash<T>{}(std::declval<T>()))>
> : std::true_type {};

// 测试
static_assert(is_hashable<int>::value, "int should be hashable");
static_assert(is_hashable<std::string>::value, "string should be hashable");
// 假设有一个没有 hash 特化的类型
struct MyType {};
static_assert(!is_hashable<MyType>::value, "MyType should not be hashable");

这个例子用到了 SFINAE 和 std::void_t。核心思路是：尝试用 std::hash<T> 去计算一个 T 类型的值，如果表达式合法，就匹配到特化版本（继承 true_type）；否则，匹配到主模板（继承 false_type）。

这种技术叫做“检测惯用法”（Detection Idiom）。我在写泛型容器时经常用到，用来判断某个类型是否支持特定操作。

知识体系总览

下面这张图总结了本章的核心内容：类型萃取的分类、标准库常见 traits、以及自定义 traits 的两种方式。

总结

类型萃取是 C++ 模板元编程的基石。它让我们能在编译期“看到”类型的属性，并根据这些属性做出决策。标准库提供了丰富的 traits，覆盖了大部分常见需求。当标准库不够用时，我们可以通过模板特化或 SFINAE 技术，轻松地自定义 traits。

记住一点：类型萃取的核心是“编译期计算”。它不会影响运行时的性能，所有的判断和变换都在编译期完成。这也是 C++ 模板元编程的魅力所在——把运行时的工作提前到编译期，让代码更高效、更安全。

---