模板进阶：可变参数模板、模板元编程基础、SFINAE、概念（C++20）

说实话，模板这块内容，是C++里最让我又爱又恨的部分。爱的是它带来的抽象能力，恨的是它那令人窒息的编译错误信息。今天咱们聊的这几个主题——可变参数模板、模板元编程、SFINAE、还有C++20的概念——说白了，就是让你从「会用模板」进化到「能驾驭模板」的关键一步。

我个人习惯把模板分为三个阶段：第一阶段是写写容器、智能指针；第二阶段是开始用模板做编译期计算；第三阶段，就是今天要聊的这些——让模板真正成为你的「编译期瑞士军刀」。

1. 可变参数模板：让函数接受任意数量的参数

我记得刚学C++那会儿，想写一个日志函数，参数个数不确定。那时候只能用C风格的va_list，类型不安全，还容易出bug。C++11引入的可变参数模板，彻底解决了这个问题。

// 基础版本：递归终止函数
void print() {
    std::cout << std::endl;
}

// 可变参数模板：参数包展开
template<typename T, typename... Args>
void print(const T& first, const Args&... rest) {
    std::cout << first << " ";
    print(rest...);  // 递归调用，每次减少一个参数
}

// 使用
print(1, 2.5, "hello", 'c');  // 输出：1 2.5 hello c

这里有个关键点：typename... Args 定义了一个模板参数包，Args... rest 声明了一个函数参数包。展开的时候用 rest... 语法。说白了，就是编译器在编译期帮你生成了一堆重载函数。

// C++17 折叠表达式：更简洁，无递归
template<typename... Args>
void print(Args... args) {
    ((std::cout << args << " "), ...);  // 一元右折叠
    std::cout << std::endl;
}

// 或者用逗号表达式展开
template<typename... Args>
void print(Args... args) {
    (..., (std::cout << args << " "));  // 一元左折叠
    std::cout << std::endl;
}

2. 模板元编程：在编译期完成计算

模板元编程，说白了就是「用模板写程序，让编译器替你运行」。你想想看，有些计算如果能在编译期完成，运行时就能省掉这些开销。比如计算阶乘、斐波那契数列，或者更复杂的类型变换。

// 编译期阶乘
template<int N>
struct Factorial {
    static constexpr int value = N * Factorial<N - 1>::value;
};

// 特化：终止条件
template<>
struct Factorial<0> {
    static constexpr int value = 1;
};

// 使用
int main() {
    constexpr int result = Factorial<5>::value;  // 编译期计算为120
    std::cout << result << std::endl;
    return 0;
}

嗯，这里要注意：模板元编程本质上是一种函数式编程。没有变量，没有循环，只有递归和特化。我刚开始写的时候特别不习惯，总觉得「这也能叫编程？」。但用多了你会发现，它在类型变换、编译期断言这些场景下，简直无敌。

3. SFINAE：模板选择的艺术

SFINAE，全称是「Substitution Failure Is Not An Error」——替换失败不是错误。这名字起得挺绕，说白了就是：当编译器尝试实例化模板时，如果某个模板参数替换导致非法代码，编译器不会报错，而是默默把这个模板从候选集中移除。

为什么会这样？因为C++允许模板重载。编译器需要从多个候选模板中选一个最合适的。如果某个模板替换失败，那就跳过它，看下一个。

// 检测类型是否有 size() 成员函数
template<typename T>
struct has_size {
private:
    // 如果 T 有 size()，这个重载会被选中
    template<typename U>
    static auto check(int) -> decltype(std::declval<U>().size(), std::true_type());

    // 否则，这个兜底重载被选中
    template<typename>
    static std::false_type check(...);

public:
    static constexpr bool value = decltype(check<T>(0))::value;
};

// 使用
static_assert(has_size<std::vector<int>>::value, "vector has size()");
static_assert(!has_size<int>::value, "int does not have size()");

这段代码里，decltype(std::declval<U>().size(), std::true_type()) 是关键。如果 U 没有 size()，这个表达式就是非法的，编译器会跳过这个重载，选择 ... 那个兜底版本。

4. 概念（C++20）：让模板约束变得优雅

终于说到概念了。C++20 的概念，说白了就是给模板参数加「标签」——明确告诉编译器：这个模板参数必须满足什么条件。以前用 SFINAE 写约束，代码又臭又长。现在用概念，一行搞定。

// 定义一个概念：可哈希的类型
template<typename T>
concept Hashable = requires(T a) {
    { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;
};

// 使用概念约束模板
template<Hashable T>
void process(const T& value) {
    auto hash = std::hash<T>{}(value);
    std::cout << "Hash: " << hash << std::endl;
}

// 或者用 requires 子句
template<typename T>
    requires std::integral<T>
T add(T a, T b) {
    return a + b;
}

// 使用
process(42);           // OK，int 可哈希
process("hello");      // OK，const char* 可哈希
// process(std::any{}); // 编译错误：std::any 不可哈希

概念的好处是什么？第一，编译错误信息变得可读。以前模板报错能给你刷几屏，现在直接告诉你「这个类型不满足某某概念」。第二，代码自文档化。看到 Hashable T，你立刻就知道这个模板要求什么。

5. 知识体系总览

下面这张图，是我梳理的本章知识体系。你可以看到，这四个主题其实是层层递进的：可变参数模板解决了「参数数量」的问题，模板元编程解决了「编译期计算」的问题，SFINAE解决了「模板选择」的问题，概念解决了「约束表达」的问题。

6. 综合示例：一个实用的类型安全工厂

最后，咱们把今天学的知识串起来，写一个实用的例子。假设你要实现一个工厂函数，根据字符串创建不同类型的对象。用可变参数模板 + 概念，可以写出类型安全、扩展性好的代码。

#include <iostream>
#include <string>
#include <memory>
#include <unordered_map>
#include <functional>

// 概念：可默认构造的类型
template<typename T>
concept DefaultConstructible = requires {
    T();
};

// 工厂类：使用可变参数模板注册创建器
template<typename Base>
class Factory {
public:
    // 注册创建器：接受任意参数
    template<typename Derived, typename... Args>
        requires std::derived_from<Derived, Base> && DefaultConstructible<Derived>
    void register_type(const std::string& name) {
        creators_[name] = []() -> std::unique_ptr<Base> {
            return std::make_unique<Derived>();
        };
    }

    // 创建对象
    std::unique_ptr<Base> create(const std::string& name) {
        auto it = creators_.find(name);
        if (it != creators_.end()) {
            return it->second();
        }
        return nullptr;
    }

private:
    std::unordered_map<std::string, std::function<std::unique_ptr<Base>()>> creators_;
};

// 使用示例
struct Animal {
    virtual void speak() = 0;
    virtual ~Animal() = default;
};

struct Dog : Animal {
    void speak() override { std::cout << "Woof!\n"; }
};

struct Cat : Animal {
    void speak() override { std::cout << "Meow!\n"; }
};

int main() {
    Factory<Animal> factory;
    factory.register_type<Dog>("dog");
    factory.register_type<Cat>("cat");

    auto animal = factory.create("dog");
    if (animal) animal->speak();  // 输出：Woof!

    return 0;
}

这个例子用到了：概念约束（确保类型可默认构造且继承自基类）、可变参数模板（虽然这里没展开，但可以扩展为接受构造参数）、以及模板元编程的思想（编译期类型检查）。

---

公众号:蓝海资料掘金营，微信deep3321