C++ 类型特征（Type Traits）：在编译期获取类型信息并进行判断

C++ 类型特征：编译期侦探的百宝箱

各位看官，各位程序界的英雄豪杰，今天咱们聊聊 C++ 里一个挺有意思，但又容易被忽略的家伙：类型特征（Type Traits）。你可能听说过它，也可能觉得这玩意儿离你很远。但我要告诉你，它就像程序世界里的“编译期侦探”，能帮你提前摸清各种类型的底细，让你的代码更健壮、更灵活，更有“逼格”。

啥是类型特征？

简单来说，类型特征就是一套在编译期就能提取和分析类型信息的工具。它能告诉你一个类型是啥玩意儿，比如是整数、浮点数、指针，还是类？它能不能被拷贝？有没有默认构造函数？是不是 POD 类型（Plain Old Data，简单数据类型）？等等等等。

你可能会问：“这玩意儿有啥用？我直接 typeid 不行吗？或者运行时 instanceof 也挺好使啊？”

别急，听我慢慢道来。 typeid 是运行时获取类型信息的，而 instanceof 在 C++ 里通常是通过 RTTI (运行时类型识别) 实现的，也是运行时的。类型特征牛逼的地方在于，它是在编译期就搞定一切。这意味着啥？

性能更高：编译期完成，运行时就省事了，速度自然杠杠的。
更安全：编译期就能发现潜在的问题，避免运行时崩溃。
更灵活：根据类型特征，在编译期选择不同的代码路径，实现编译期多态。

想象一下，你写了一个模板函数，希望它能处理整数和浮点数。如果直接用 + 来计算，那没问题。但如果用户传进来一个字符串呢？编译器就会报错，告诉你 string 类型没有 + 操作符。这时候，类型特征就能派上用场了。你可以用它来判断传入的类型是不是数值类型，如果是，就进行加法运算，否则就抛出一个编译期错误，提前避免了运行时的问题。

类型特征家族谱

C++11 开始，标准库 <type_traits> 头文件里就提供了丰富的类型特征。咱们来认识几个常用的族人：

基本类型判断：
- std::is_integral<T>：判断 T 是不是整数类型 (如 int, long, bool)。
- std::is_floating_point<T>：判断 T 是不是浮点数类型 (如 float, double)。
- std::is_pointer<T>：判断 T 是不是指针类型。
- std::is_class<T>：判断 T 是不是类类型。
- std::is_enum<T>：判断 T 是不是枚举类型。
- std::is_union<T>：判断 T 是不是联合体类型。
类型属性查询：
- std::is_const<T>：判断 T 是不是 const 类型。
- std::is_volatile<T>：判断 T 是不是 volatile 类型。
- std::is_lvalue_reference<T>：判断 T 是不是左值引用类型。
- std::is_rvalue_reference<T>：判断 T 是不是右值引用类型。
- std::is_pod<T>：判断 T 是不是 POD 类型。
- std::is_empty<T>：判断 T 是不是空类。
- std::is_standard_layout<T>：判断 T 是不是标准布局类型。
- std::has_virtual_destructor<T>：判断 T 是否有虚析构函数。
类型关系判断：
- std::is_same<T, U>：判断 T 和 U 是不是同一种类型。
- std::is_base_of<Base, Derived>：判断 Base 是不是 Derived 的基类。
- std::is_convertible<From, To>：判断 From 类型能不能隐式转换为 To 类型。
类型转换：
- std::remove_const<T>：移除 T 的 const 属性。
- std::remove_volatile<T>：移除 T 的 volatile 属性。
- std::remove_pointer<T>：移除 T 的指针属性。
- std::add_const<T>：添加 const 属性到 T。
- std::add_pointer<T>：添加指针属性到 T。
- std::decay<T>：将 T 类型转换为函数参数传递或数组转换为指针时的类型。

这些类型特征都长得像模板类，它们都有一个静态成员变量 value，它的类型是 bool，表示判断的结果。比如：

#include <iostream>
#include <type_traits>

int main() {
  std::cout << std::is_integral<int>::value << std::endl; // 输出 1 (true)
  std::cout << std::is_floating_point<double>::value << std::endl; // 输出 1 (true)
  std::cout << std::is_pointer<int*>::value << std::endl; // 输出 1 (true)
  std::cout << std::is_integral<std::string>::value << std::endl; // 输出 0 (false)

  return 0;
}

类型特征的实际应用

光说不练假把式，咱们来几个实际的例子，看看类型特征怎么在代码里大显身手。

1. 模板函数特化

假设我们要写一个模板函数，用来打印变量的值。但是，对于指针类型，我们希望打印的是指针指向的值，而不是指针本身的地址。这时候，就可以用类型特征来实现模板特化：

#include <iostream>
#include <type_traits>

// 通用模板函数，打印变量的值
template <typename T>
void print_value(T value) {
  std::cout << "Value: " << value << std::endl;
}

// 针对指针类型的特化版本
template <typename T>
void print_value(T* value) {
  std::cout << "Value (pointed to): " << *value << std::endl;
  std::cout << "Address: " << value << std::endl;
}

int main() {
  int x = 10;
  int* ptr = &x;
  double y = 3.14;

  print_value(x); // 调用通用版本，输出 "Value: 10"
  print_value(ptr); // 调用指针特化版本，输出 "Value (pointed to): 10" 和 "Address: 0x..."
  print_value(y); // 调用通用版本，输出 "Value: 3.14"

  return 0;
}

这个例子虽然简单，但展示了类型特征的一个重要用途：根据不同的类型，选择不同的代码路径。

2. 静态断言 (static_assert)

static_assert 是 C++11 引入的一个关键字，它允许你在编译期进行断言检查。如果断言条件不成立，编译器就会报错。这玩意儿和类型特征简直是天生一对。

比如，你写了一个函数，要求传入的参数必须是整数类型。你可以用 static_assert 和 std::is_integral 来确保这一点：

#include <iostream>
#include <type_traits>

template <typename T>
void process_integer(T value) {
  static_assert(std::is_integral<T>::value, "Error: Only integer types are allowed.");
  std::cout << "Processing integer: " << value << std::endl;
}

int main() {
  process_integer(10); // OK
  //process_integer(3.14); // 编译错误：Error: Only integer types are allowed.

  return 0;
}

这样，如果在编译期传入了非整数类型，编译器就会报错，避免了运行时出现不可预知的错误。

3. SFINAE (Substitution Failure Is Not An Error)

SFINAE 是 C++ 模板编程里一个非常重要的概念。简单来说，它指的是在模板参数推导过程中，如果某个模板实例化失败，编译器不会直接报错，而是会忽略这个实例化，继续尝试其他的可能性。

类型特征经常被用来配合 SFINAE，实现更高级的编译期选择。举个例子，假设我们要写一个函数，用来计算两个数的和。但是，我们希望这个函数只对数值类型有效。如果传入的类型不是数值类型，我们就禁用这个函数。

#include <iostream>
#include <type_traits>

template <typename T, typename U,
          typename = typename std::enable_if<
              std::is_arithmetic<T>::value && std::is_arithmetic<U>::value
          >::type>
auto add(T a, U b) -> decltype(a + b) {
  return a + b;
}

int main() {
  std::cout << add(10, 20) << std::endl; // OK
  std::cout << add(3.14, 2.71) << std::endl; // OK
  //std::cout << add("hello", "world") << std::endl; // 编译错误：没有匹配的函数

  return 0;
}

在这个例子里，我们用 std::enable_if 和 std::is_arithmetic 来实现 SFINAE。 std::enable_if 的作用是：如果第一个模板参数（这里是 std::is_arithmetic<T>::value && std::is_arithmetic<U>::value）为真，那么它就提供一个类型（默认为 void）；否则，它就不提供任何类型。如果 std::enable_if 没有提供任何类型，那么模板实例化就会失败，但编译器不会报错，而是继续尝试其他的重载版本。

4. 类型转换和萃取

有时候，我们需要对类型进行转换或者萃取，比如移除 const 属性、添加指针属性、获取类型的底层类型等等。类型特征提供了一系列工具来实现这些操作。

#include <iostream>
#include <type_traits>

int main() {
  using ConstInt = const int;
  using NonConstInt = std::remove_const<ConstInt>::type;

  std::cout << std::is_const<ConstInt>::value << std::endl; // 输出 1
  std::cout << std::is_const<NonConstInt>::value << std::endl; // 输出 0

  using IntPtr = int*;
  using IntPtrPtr = std::add_pointer<int>::type;

  std::cout << std::is_same<IntPtr, IntPtrPtr>::value << std::endl; // 输出 1

  return 0;
}

自定义类型特征

标准库提供的类型特征已经很丰富了，但有时候我们还是需要自定义类型特征，来满足一些特殊的需求。

自定义类型特征也很简单，只需要定义一个模板类，然后提供一个静态成员变量 value，它的类型是 bool，表示判断的结果。

举个例子，假设我们要判断一个类型是不是可默认构造的（也就是说，它有没有默认构造函数）。

#include <iostream>
#include <type_traits>

template <typename T>
struct is_default_constructible {
  template <typename U>
  static constexpr decltype(U(), bool()) test(int) { return true; }

  template <typename U>
  static constexpr bool test(...) { return false; }

  static constexpr bool value = test<T>(0);
};

class A {
public:
  A(int x) {} // 没有默认构造函数
};

class B {
public:
  B() {} // 有默认构造函数
};

int main() {
  std::cout << is_default_constructible<A>::value << std::endl; // 输出 0
  std::cout << is_default_constructible<B>::value << std::endl; // 输出 1

  return 0;
}

这个例子稍微有点复杂，用到了 SFINAE 的技巧。 test 函数有两个重载版本：

第一个版本接受一个 int 参数，并且尝试调用 U() 来创建一个 U 类型的对象。如果 U 类型有默认构造函数，那么这个调用就会成功， test 函数返回 true。
第二个版本是省略号参数，它可以匹配任何参数。如果 U 类型没有默认构造函数，那么第一个版本的 test 函数就会实例化失败，编译器会选择第二个版本， test 函数返回 false。

类型特征的注意事项

编译期计算：类型特征的所有计算都是在编译期完成的，所以不要指望它能处理运行时的类型信息。
类型萃取：类型特征只能提取类型的静态信息，不能修改类型本身。
标准库依赖：类型特征依赖于标准库，所以确保你的编译器支持 C++11 或更高版本。

总结

类型特征是 C++ 模板编程里的一把利器。它可以让你在编译期获取类型信息，进行各种判断和转换，从而写出更健壮、更灵活、更高效的代码。掌握了类型特征，你就能像一个编译期侦探一样，提前发现潜在的问题，避免运行时踩坑。以后再写模板代码的时候，不妨多想想类型特征，它可能会给你带来意想不到的惊喜。

好了，今天的分享就到这里。希望这篇文章能让你对类型特征有一个更清晰的认识。祝各位程序猿们编码愉快，bug 越来越少！