第四节 · 无限剑制 · 可变参数模板

<type_traits> 头文件提供了丰富的类型查询和转换工具，是现代 C++ 泛型编程的基础。

---

基本类型查询

#include <type_traits>

int main()
{
    // 检查基本类型
    cout << is_integral<int>::value << endl;        // 1
    cout << is_floating_point<double>::value << endl;  // 1
    cout << is_arithmetic<char>::value << endl;     // 1
    
    // C++17 简化语法
    cout << is_integral_v<int> << endl;             // 1
    
    // 检查指针和引用
    cout << is_pointer_v<int*> << endl;             // 1
    cout << is_reference_v<int&> << endl;           // 1
    cout << is_lvalue_reference_v<int&> << endl;    // 1
    cout << is_rvalue_reference_v<int&&> << endl;   // 1
    
    return 0;
}

---

复合类型查询

class MyClass {};
struct MyStruct {};
enum MyEnum { A, B };
union MyUnion { int i; double d; };

int main()
{
    cout << is_class_v<MyClass> << endl;     // 1
    cout << is_class_v<MyStruct> << endl;    // 1
    cout << is_enum_v<MyEnum> << endl;       // 1
    cout << is_union_v<MyUnion> << endl;     // 1
    
    cout << is_array_v<int[5]> << endl;      // 1
    cout << is_function_v<void()> << endl;   // 1
    
    return 0;
}

---

类型属性

class Base { virtual void foo() {} };
class Derived : public Base {};
class Abstract { virtual void foo() = 0; };

int main()
{
    // 类属性
    cout << is_abstract_v<Abstract> << endl;     // 1
    cout << is_polymorphic_v<Base> << endl;      // 1
    cout << is_final_v<Derived> << endl;         // 0
    
    // 特殊成员函数
    cout << is_default_constructible_v<int> << endl;     // 1
    cout << is_copy_constructible_v<string> << endl;     // 1
    cout << is_move_constructible_v<unique_ptr<int>> << endl;  // 1
    cout << is_copy_assignable_v<unique_ptr<int>> << endl;     // 0
    
    return 0;
}

---

类型关系

class Base {};
class Derived : public Base {};

int main()
{
    // 相同类型
    cout << is_same_v<int, int> << endl;         // 1
    cout << is_same_v<int, int&> << endl;        // 0
    
    // 继承关系
    cout << is_base_of_v<Base, Derived> << endl;  // 1
    cout << is_base_of_v<Derived, Base> << endl;  // 0
    
    // 可转换
    cout << is_convertible_v<Derived*, Base*> << endl;  // 1
    cout << is_convertible_v<int, double> << endl;      // 1
    
    return 0;
}

---

类型修改

int main()
{
    // 移除 const/volatile
    using T1 = remove_const_t<const int>;        // int
    using T2 = remove_volatile_t<volatile int>;  // int
    using T3 = remove_cv_t<const volatile int>;  // int
    
    // 添加 const/volatile
    using T4 = add_const_t<int>;                 // const int
    
    // 移除引用
    using T5 = remove_reference_t<int&>;         // int
    using T6 = remove_reference_t<int&&>;        // int
    
    // 移除指针
    using T7 = remove_pointer_t<int*>;           // int
    using T8 = remove_pointer_t<int**>;          // int*
    
    // 移除数组维度
    using T9 = remove_extent_t<int[5]>;          // int
    using T10 = remove_all_extents_t<int[3][4]>; // int
    
    return 0;
}

---

条件类型

int main()
{
    // conditional: 条件类型选择
    using T1 = conditional_t<true, int, double>;   // int
    using T2 = conditional_t<false, int, double>;  // double
    
    // 根据大小选择类型
    using BigInt = conditional_t<(sizeof(long) > 4), long, long long>;
    
    // enable_if: 条件启用
    // 见前面的 SFINAE 章节
    
    return 0;
}

---

decay

decay 模拟值传递时的类型转换。

int main()
{
    // decay: 退化（像函数参数传递那样）
    using T1 = decay_t<int&>;        // int
    using T2 = decay_t<int&&>;       // int
    using T3 = decay_t<const int&>;  // int
    using T4 = decay_t<int[5]>;      // int*
    using T5 = decay_t<int(double)>; // int(*)(double)
    
    cout << is_same_v<T4, int*> << endl;  // 1
    
    return 0;
}

---

common_type

找出多个类型的公共类型。

int main()
{
    using T1 = common_type_t<int, double>;        // double
    using T2 = common_type_t<int, long, double>;  // double
    
    // 实际应用
    template<typename T, typename U>
    common_type_t<T, U> add(T a, U b)
    {
        return a + b;
    }
    
    auto result = add(1, 2.5);  // double
    
    return 0;
}

---

实用工具

#include <type_traits>

// 带条件的函数重载
template<typename T>
enable_if_t<is_integral_v<T>, T>
process(T value)
{
    cout << "Processing integer: " << value << endl;
    return value * 2;
}

template<typename T>
enable_if_t<is_floating_point_v<T>, T>
process(T value)
{
    cout << "Processing float: " << value << endl;
    return value * 2.0;
}

// 类型安全的位操作
template<typename T>
enable_if_t<is_unsigned_v<T>, T>
safeBitAnd(T a, T b)
{
    return a & b;
}

int main()
{
    process(42);     // Processing integer: 42
    process(3.14);   // Processing float: 3.14
    
    unsigned int a = 0xFF, b = 0x0F;
    cout << hex << safeBitAnd(a, b) << endl;  // f
    
    return 0;
}

---

void_t 技巧

// 检测是否有 iterator 类型
template<typename, typename = void>
struct has_iterator : false_type {};

template<typename T>
struct has_iterator<T, void_t<typename T::iterator>> : true_type {};

// 检测是否有 size() 方法
template<typename, typename = void>
struct has_size : false_type {};

template<typename T>
struct has_size<T, void_t<decltype(declval<T>().size())>> : true_type {};

int main()
{
    cout << has_iterator<vector<int>>::value << endl;  // 1
    cout << has_iterator<int>::value << endl;          // 0
    
    cout << has_size<vector<int>>::value << endl;      // 1
    cout << has_size<int>::value << endl;              // 0
    
    return 0;
}

---

习题

• 使用 type_traits 实现一个只接受数字类型的模板函数。

• 编写检测类型是否有特定成员函数的模板。

• 解释 decay_t 的作用和使用场景。