C++ 模板进阶

作为 C++ 泛型编程的核心，模板进阶特性（特化、萃取、可变参数模板）能让你写出更通用、更高效、更灵活的代码。下面我会从基础概念到实际应用，由浅入深讲解这三个核心知识点。

一、模板特化：为特定类型定制逻辑

模板特化的本质是「通用模板 + 特殊实现」，当编译器匹配到特定类型时，优先使用特化版本，而非通用模板。

1. 核心概念

模板特化分为两种：

• 全特化 ：为模板的所有模板参数指定具体类型。
• 偏特化 ：只为模板的部分参数指定类型，或对参数做约束（仅针对类模板）。

2. 代码示例

（1）函数模板全特化

cpp

运行

#include <iostream>
#include <string>

// 通用模板
template <typename T>
void print(T value) {
    std::cout << "通用版本: " << value << std::endl;
}

// 针对string类型的全特化
template <>
void print<std::string>(std::string value) {
    std::cout << "string特化版本: " << "[字符串] " << value << std::endl;
}

// 针对int类型的全特化
template <>
void print<int>(int value) {
    std::cout << "int特化版本: " << "[整数] " << value << std::endl;
}

int main() {
    print(100);        // 匹配int特化版本
    print(3.14);       // 匹配通用版本
    print(std::string("Hello")); // 匹配string特化版本
    return 0;
}

输出结果：

plaintext

int特化版本: [整数] 100
通用版本: 3.14
string特化版本: [字符串] Hello

（2）类模板偏特化

cpp

运行

#include <iostream>

// 通用类模板
template <typename T, typename U>
class MyClass {
public:
    MyClass() { std::cout << "通用版本: T=" << typeid(T).name() << ", U=" << typeid(U).name() << std::endl; }
};

// 偏特化1：第二个参数固定为int
template <typename T>
class MyClass<T, int> {
public:
    MyClass() { std::cout << "偏特化版本1: T=" << typeid(T).name() << ", U=int" << std::endl; }
};

// 偏特化2：两个参数都是指针类型
template <typename T, typename U>
class MyClass<T*, U*> {
public:
    MyClass() { std::cout << "偏特化版本2: T*=" << typeid(T).name() << ", U*=" << typeid(U).name() << std::endl; }
};

int main() {
    MyClass<float, double> c1;  // 通用版本
    MyClass<float, int> c2;     // 偏特化版本1
    MyClass<int*, char*> c3;    // 偏特化版本2
    return 0;
}

核心说明：偏特化仅适用于类模板，函数模板不支持偏特化（若需类似效果，可通过函数重载实现）。

二、类型萃取（Type Traits）：提取类型的「元信息」

类型萃取是泛型编程的「工具箱」，核心作用是在编译期获取 / 修改类型的属性（比如判断是否是指针、是否是常量、提取指针指向的原始类型等），实现「类型判断 - 分支逻辑」的编译期决策。

1. 核心原理

类型萃取基于模板特化 + 静态常量 / 类型别名实现，利用编译器的模板匹配机制，在编译期确定类型属性，无运行时开销。

2. 代码示例：自定义简单类型萃取

cpp

运行

#include <iostream>

// 1. 通用版本：判断是否为指针类型（默认false）
template <typename T>
struct is_pointer {
    static constexpr bool value = false; // 编译期常量
};

// 2. 特化版本：指针类型匹配（value=true）
template <typename T>
struct is_pointer<T*> {
    static constexpr bool value = true;
};

// 3. 萃取指针的原始类型
template <typename T>
struct remove_pointer {
    using type = T; // 通用版本：类型不变
};

template <typename T>
struct remove_pointer<T*> {
    using type = T; // 特化版本：去掉指针，返回原始类型
};

// 辅助函数：简化使用
template <typename T>
constexpr bool is_pointer_v = is_pointer<T>::value;

template <typename T>
using remove_pointer_t = typename remove_pointer<T>::type;

int main() {
    // 1. 判断是否为指针
    std::cout << "int是否为指针: " << is_pointer_v<int> << std::endl;       // 0
    std::cout << "int*是否为指针: " << is_pointer_v<int*> << std::endl;     // 1

    // 2. 提取指针原始类型
    remove_pointer_t<int*> a = 10; // a的类型是int
    std::cout << "a的类型: " << typeid(a).name() << std::endl; // int
    return 0;
}

实际应用 ：C++ 标准库<type_traits>提供了丰富的萃取工具（如std::is_int、std::is_const、std::remove_reference等），无需重复造轮子。

三、可变参数模板：处理任意数量的参数

可变参数模板（Variadic Templates）允许模板接受0 个或多个 模板参数 / 函数参数，是实现「泛型可变参数函数 / 类」的核心（比如std::printf、std::tuple的底层实现）。

1. 核心语法

• 模板参数包：template <typename... Args>（Args是参数包，可包含任意数量的类型）。
• 函数参数包：void func(Args... args)（args是参数包，对应模板参数包的实例）。
• 包展开：args...（通过...展开参数包，逐个处理每个参数）。

2. 代码示例

（1）可变参数函数模板（递归展开）

cpp

运行

#include <iostream>

// 1. 终止函数：参数包为空时调用（递归出口）
void print_args() {
    std::cout << "参数包结束" << std::endl;
}

// 2. 递归函数：展开参数包（每次处理第一个参数，剩余参数继续递归）
template <typename T, typename... Args>
void print_args(T first, Args... rest) {
    std::cout << "参数: " << first << " | 剩余参数数: " << sizeof...(rest) << std::endl;
    print_args(rest...); // 展开剩余参数包
}

int main() {
    print_args(10, 3.14, std::string("Hello"), 'A');
    return 0;
}

输出结果：

plaintext

参数: 10 | 剩余参数数: 3
参数: 3.14 | 剩余参数数: 2
参数: Hello | 剩余参数数: 1
参数: A | 剩余参数数: 0
参数包结束

（2）可变参数类模板（std::tuple 简化实现）

cpp

运行

#include <iostream>

// 1. 通用类模板（递归定义）
template <typename... Args>
struct Tuple;

// 2. 特化版本1：空参数包（递归出口）
template <>
struct Tuple<> {
    Tuple() { std::cout << "空Tuple" << std::endl; }
};

// 3. 特化版本2：包含至少一个参数（拆分第一个参数和剩余参数）
template <typename T, typename... Args>
struct Tuple<T, Args...> : Tuple<Args...> {
    T value;
    Tuple(T v, Args... args) : Tuple<Args...>(args...), value(v) {
        std::cout << "添加参数: " << typeid(T).name() << " = " << v << std::endl;
    }
};

int main() {
    Tuple<int, double, std::string> t(10, 3.14, "Hello");
    return 0;
}

输出结果：

plaintext

空Tuple
添加参数: double = 3.14
添加参数: int = 10

---

总结

1. 模板特化：为特定类型 / 参数组合定制模板实现，分为全特化（所有参数指定）和偏特化（部分参数指定，仅类模板），解决通用模板的「特殊场景适配」问题。
2. 类型萃取：基于模板特化在编译期提取 / 修改类型属性（如判断指针、去除 const），无运行时开销，是泛型编程的核心工具。
3. 可变参数模板 ：通过参数包（...）处理任意数量的参数，需配合递归 / 折叠表达式展开，常用于实现通用容器（如 tuple）、可变参数函数（如 printf）。