Java 开发者学 C++（八）：模板与泛型编程

从 Java 泛型到 C++ 模板：截然不同的哲学

Java 开发者看到 C++ 模板的第一反应通常是"这不就是泛型吗？"——这是 C++ 入门的最大误解之一。

一句话总结：Java 泛型是编译时类型擦除，C++ 模板是编译时代码生成。

// C++：每个实例化生成独立代码
std::vector<int> vi;
std::vector<double> vd;
// vector<int> 和 vector<double> 是完全不同的类型
// vi 和 vd 没有继承关系，它们的 .begin() 返回不同类型

// Java：运行时只有一份 ArrayList 字节码
List<String> a = new ArrayList<>();
List<Integer> b = new ArrayList<>();
// a.getClass() == b.getClass() → true（类型信息被擦除）

Java 泛型在编译后类型参数被擦除为上限类型（或 Object）；C++ 模板在编译期为每种类型参数组合生成一份独立的机器码。这带来了完全不同的能力与约束。

核心差异对照

函数模板

最简单的模板形式：编译器根据实参自动推导类型参数。

template <typename T>  // typename 和 class 关键字可互换
T max(T a, T b) {
    return a > b ? a : b;
}

int m1 = max(3, 7);                           // T = int，推导为 int max(int, int)
double m2 = max(3.14, 2.72);                  // T = double
std::string m3 = max(std::string("a"),
                     std::string("b"));       // T = std::string

对比 Java：

// Java 泛型方法——必须显式声明边界
public static <T extends Comparable<T>> T max(T a, T b) {
    return a.compareTo(b) > 0 ? a : b;
}

关键区别：

• C++ 不需要 Comparable 约束——只要类型支持 > 运算符就行。这意味着自定义类型只要重载了 operator> 即可使用，无需继承任何接口
• C++ 模板可以直接传 int、double，不用包装类
• 类型推导是 C++ 编译器的强项——多数情况下你不用显式指定 <类型>

模板参数推导与歧义

template <typename T>
T max(T a, T b) { return a > b ? a : b; }

// max(1, 3.14);      // 编译错误！T 推导冲突（int vs double）
max<double>(1, 3.14); // 显式指定 T = double，int 1 隐式转换为 double

多个类型参数

template <typename T, typename U>
auto max(T a, U b) -> decltype(a > b ? a : b) {
    return a > b ? a : b;
}

// C++14 起可以用 auto 推断返回类型
template <typename T, typename U>
auto max(T a, U b) {
    return a > b ? a : b;
}

非类型模板参数

C++ 模板可以接受值参数（不仅是类型），Java 泛型做不到这一点。

template <typename T, int Size>
class FixedArray {
    T data[Size];
public:
    int size() const { return Size; }
    T& operator[](int i) { return data[i]; }
};

FixedArray<int, 100> arr;  // 编译期确定大小
// Size 必须是编译期常量（constexpr）

类模板

template <typename T>
class Stack {
    std::vector<T> elements;
public:
    void push(const T& elem) { elements.push_back(elem); }
    T pop() {
        T top = elements.back();
        elements.pop_back();
        return top;
    }
    bool empty() const { return elements.empty(); }
};

Stack<int> intStack;
Stack<std::string> stringStack;
// Stack<int> 和 Stack<std::string> 是完全不同的类型，无继承关系

模板成员函数

template <typename T>
class Wrapper {
    T value;
public:
    Wrapper(T v) : value(v) {}

    template <typename U>
    auto convertTo() const {
        return static_cast<U>(value);
    }
};

Wrapper<double> w(3.14);
int i = w.convertTo<int>();      // 3

模板特化（Java 完全没有的概念）

模板特化允许为特定类型参数提供不同的实现。

完全特化（Full Specialization）

// 通用模板
template <typename T>
class Printer {
public:
    void print(const T& value) {
        std::cout << value << std::endl;
    }
};

// 完全特化：为 bool 定制输出格式
template <>
class Printer<bool> {
public:
    void print(const bool& value) {
        std::cout << (value ? "true" : "false") << std::endl;
    }
};

// 完全特化：为 std::vector 提供格式化输出
template <typename T>
class Printer<std::vector<T>> {
public:
    void print(const std::vector<T>& vec) {
        std::cout << "[";
        for (size_t i = 0; i < vec.size(); ++i) {
            if (i) std::cout << ", ";
            std::cout << vec[i];
        }
        std::cout << "]" << std::endl;
    }
};

部分特化（Partial Specialization）——C++ 独有

部分特化允许你特化模板的"一部分"参数。

// 为指针类型定制的部分特化
template <typename T>
class Printer<T*> {
public:
    void print(const T* ptr) {
        if (ptr)
            std::cout << *ptr << " (@" << static_cast<const void*>(ptr) << ")";
        else
            std::cout << "nullptr";
    }
};

// 为 const 指针的部分特化
template <typename T>
class Printer<const T*> {
public:
    void print(const T* ptr) {
        std::cout << "const: ";
        if (ptr) Printer<T>().print(*ptr);
        else std::cout << "nullptr";
    }
};

Java 做不到——Java 无法说"当类型参数是某个具体类型时用不同实现"，更不用说部分特化了。

变参模板（Variadic Templates，C++11）

C++11 引入变参模板，允许模板接受任意数量的参数。

基础：递归展开

// 终止条件（0 参数版本）
void print() {}

// 递归展开：处理第一个参数，然后递归处理剩余参数
template <typename T, typename... Args>
void print(T first, Args... rest) {
    std::cout << first << " ";
    print(rest...);
}

print(1, 2.5, "hello", 'c');  // 输出: 1 2.5 hello c

C++17 折叠表达式（Fold Expressions）

C++17 大幅简化了变参模板的展开，无需递归：

template <typename... Args>
auto sum(Args... args) {
    return (... + args);      // 一元左折：((a+b)+c)+d
}

template <typename... Args>
auto sum_right(Args... args) {
    return (args + ...);      // 一元右折：(a+(b+(c+d)))
}

// 二元折叠：带初始值
template <typename... Args>
auto sum_init(Args... args) {
    return (0 + ... + args);  // (((0+a)+b)+c)+d
}

// 打印所有参数（用逗号运算符）
template <typename... Args>
void print_all(Args... args) {
    ((std::cout << args << " "), ...);  // 逗号折叠
}

sizeof... 运算符

template <typename... Args>
void count_args(Args... args) {
    std::cout << "参数个数: " << sizeof...(Args) << std::endl;
    std::cout << "参数个数（运行时）: " << sizeof...(args) << std::endl;
}

别名模板（Alias Templates，C++11）

C++11 的 using 比传统 typedef 强大得多，可以创建"模板别名"：

// 普通类型别名
using IntVector = std::vector<int>;

// 模板别名（typedef 完全做不到！）
template <typename T>
using StringMap = std::map<std::string, T>;

StringMap<int> config;      // std::map<std::string, int>
StringMap<double> prices;   // std::map<std::string, double>

// 进阶：用于简化复杂模板类型
template <typename T>
using Vec = std::vector<T>;

Vec<int> v1;                // std::vector<int>

对比 Java：Java 的 typealias 直到很晚才引入，且不支持泛型别名。

SFINAE（Substitution Failure Is Not An Error）

SFINAE 是 C++ 模板的核心原则：当模板参数替换失败时，不报错，仅仅从重载集合中移除该候选。这是现代 C++ 模板技术的基础。

完整 SFINAE 示例：enable_if

#include <type_traits>
#include <iostream>

// 仅对整数类型启用的重载
template <typename T>
typename std::enable_if_t<std::is_integral_v<T>, T>
process(T value) {
    std::cout << "整数处理: " << value << std::endl;
    return value * 2;
}

// 仅对浮点类型启用的重载
template <typename T>
typename std::enable_if_t<std::is_floating_point_v<T>, T>
process(T value) {
    std::cout << "浮点处理: " << value << std::endl;
    return value * 1.5;
}

// 仅对字符串启用的重载
template <typename T>
typename std::enable_if_t<std::is_same_v<T, std::string>, T>
process(T value) {
    std::cout << "字符串处理: " << value << std::endl;
    return value + "!";
}

int main() {
    process(42);              // 整数处理: 42
    process(3.14);            // 浮点处理: 3.14
    process(std::string("hello"));  // 字符串处理: hello
    // process(true);         // 编译错误——没有匹配的重载
}

更实用的 SFINAE：检测成员是否存在

#include <type_traits>
#include <iostream>

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

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

template <typename T>
constexpr bool has_size_v = has_size<T>::value;

// 用法
static_assert(has_size_v<std::vector<int>>);   // true
static_assert(has_size_v<std::string>);          // true
static_assert(!has_size_v<int>);                 // false

// C++17 if constexpr 配合 SFINAE
template <typename T>
void print_size(const T& container) {
    if constexpr (has_size_v<T>) {
        std::cout << "Size: " << container.size() << std::endl;
    } else {
        std::cout << "此类型没有 size()" << std::endl;
    }
}

注意：C++20 的 Concept 是一种更优雅的替代方案，后面会介绍。

C++11/14 增强：auto 和 decltype

auto 作为模板参数

// C++20 简写函数模板——等同于 template<typename T> T foo(T x)
auto foo(auto x) {
    return x + 1;
}

// 等价于：
template <typename T>
T foo(T x) { return x + 1; }

decltype 和尾置返回类型

template <typename T, typename U>
auto multiply(T a, U b) -> decltype(a * b) {
    return a * b;
}

// C++14 简写（auto 自动推导返回类型）
template <typename T, typename U>
auto multiply(T a, U b) {
    return a * b;
}

constexpr if（C++17）

C++17 的 if constexpr 在编译期进行分支选择，未选择的分支不实例化——这是模板元编程的革命性简化。

template <typename T>
void process(T value) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "整数: " << value << std::endl;
    } else if constexpr (std::is_floating_point_v<T>) {
        std::cout << "浮点: " << std::fixed << std::setprecision(2)
                  << value << std::endl;
    } else if constexpr (std::is_same_v<T, std::string>) {
        std::cout << "字符串: \"" << value << "\"" << std::endl;
    } else {
        std::cout << "未知类型" << std::endl;
    }
}

对比旧的 SFINAE 方式，if constexpr 可读性远超 SFINAE。

模板元编程（编译期计算）

模板元编程是 C++ 独有的能力——在编译期执行计算。

编译期阶乘

// 递归模板——编译期计算
template <unsigned int N>
struct Factorial {
    static constexpr unsigned int value = N * Factorial<N - 1>::value;
};

template <>
struct Factorial<0> {
    static constexpr unsigned int value = 1;
};

int main() {
    constexpr auto f5 = Factorial<5>::value;  // 编译期已算出 120
    std::cout << f5 << std::endl;              // 运行时无计算
    static_assert(Factorial<5>::value == 120);  // 编译期验证
}

constexpr 函数（更简单的方式）

// C++14 的 constexpr 函数——比模板元编程简单得多
constexpr unsigned int factorial(unsigned int n) {
    unsigned int result = 1;
    for (unsigned int i = 2; i <= n; ++i)
        result *= i;
    return result;
}

static_assert(factorial(5) == 120);  // 编译期执行
int arr[factorial(3)];               // 编译期常量可用作数组大小

类型萃取（Type Traits）

#include <type_traits>

// 常见的类型萃取
static_assert(std::is_integral_v<int>);              // true
static_assert(!std::is_floating_point_v<int>);       // true
static_assert(std::is_same_v<int, int>);             // true
static_assert(!std::is_const_v<int>);                // true
static_assert(std::is_const_v<const int>);           // true
static_assert(std::is_pointer_v<int*>);              // true

// 类型修饰
using NonConst = std::remove_const_t<const int>;     // int
using AddPtr = std::add_pointer_t<int>;              // int*
using Decayed = std::decay_t<const int&>;            // int

C++20 Concept（约束与概念）

Concept 是 C++20 最重要的新特性之一，它让模板的约束变得清晰、错误信息友好。

定义和使用 Concept

#include <concepts>
#include <iostream>
#include <string>
#include <unordered_set>

// 定义一个 Concept：类型 T 必须是"可哈希的"
template <typename T>
concept Hashable = requires(T t) {
    { std::hash<T>{}(t) } -> std::convertible_to<std::size_t>;
};

// 三种使用 Concept 的语法

// 方式1：template 参数约束（推荐）
template <Hashable T>
void process_hash(const T& value) {
    auto h = std::hash<T>{}(value);
    std::cout << "Hash: " << h << std::endl;
}

// 方式2：简写语法（C++20）
void process_hash_short(const Hashable auto& value) {
    auto h = std::hash<decltype(value)>{}(value);
    std::cout << "Hash: " << h << std::endl;
}

// 方式3：requires 子句
template <typename T>
    requires Hashable<T>
void process_hash_req(const T& value) {
    auto h = std::hash<T>{}(value);
    std::cout << "Hash: " << h << std::endl;
}

int main() {
    process_hash(42);                // 编译通过：int 有 std::hash
    process_hash(std::string("hi")); // 编译通过：string 有 std::hash
    // process_hash(std::unordered_set<int>{}); // 编译错误！错误信息清晰指出不满足 Hashable
}

更复杂的 Concept

// 组合 Concept
template <typename T>
concept Numeric = std::is_arithmetic_v<T>;

template <typename T>
concept Printable = requires(T t, std::ostream& os) {
    { os << t } -> std::same_as<std::ostream&>;
};

template <typename T>
concept NumericPrintable = Numeric<T> && Printable<T>;

template <NumericPrintable T>
T square(T value) {
    std::cout << "计算平方: " << value << " → ";
    return value * value;
}

// 检查多个参数
template <typename T, typename U>
concept Addable = requires(T a, U b) {
    { a + b } -> std::convertible_to<decltype(a + b)>;
};

template <Addable T, Addable<U> auto>
auto add(T a, U b) { return a + b; }

Java 泛型通配符 vs C++ Concept

Java 的 ? extends T 和 ? super T 用于协变/逆变，这是类型擦除的产物。C++ 模板默认就是"不变"的，但可以通过 Concept 约束实现类似效果：

// Java: void process(List<? extends Number> list)
// C++ Concept 等效：
template <typename T>
concept Number = std::is_arithmetic_v<T>;

template <Number T>
void process(const std::vector<T>& vec) {
    for (const auto& v : vec)
        std::cout << v << " ";
}

编码好习惯与坏味道

✅ 好习惯

① 模板实现放头文件

模板实例化发生在编译期，编译器需要在调用点看到完整定义——所以模板必须放在头文件中。

// ✅ 正确：头文件中包含完整实现
// utils.hpp
#pragma once
template <typename T>
T max(T a, T b) { return a > b ? a : b; }

// ❌ 错误：模板定义放在 .cpp 中，链接时报错"未定义引用"
// utils.hpp — 只有声明
// template <typename T> T max(T a, T b);
// utils.cpp — 定义
// template <typename T> T max(T a, T b) { return a > b ? a : b; }
// main.cpp — #include "utils.hpp" → 链接错误！

② 用 static_assert 做编译期检查

template <typename T>
class DataProcessor {
    static_assert(std::is_default_constructible_v<T>,
                  "DataProcessor 要求类型 T 可默认构造");
    static_assert(std::is_copy_constructible_v<T>,
                  "DataProcessor 要求类型 T 可拷贝构造");
    // ...
};

③ C++20 优先用 Concept 而不是 SFINAE

// ❌ C++98 风格：SFINAE enable_if 晦涩难读
template <typename T>
typename std::enable_if_t<std::is_integral_v<T>, T>
foo(T t) { return t; }

// ✅ C++20 风格：Concept 清晰可读
template <std::integral T>
T foo(T t) { return t; }

④ 函数模板用 const T& 传参避免不必要的拷贝

template <typename T>
void process(const T& value);  // ✅ 避免拷贝大对象

// 但对于 int 等小类型，按值传递可能更高效
template <typename T>
auto square(T value) -> decltype(value * value) {
    return value * value;  // ✅ 小类型按值传
}

⑤ 对模板参数用 inline 避免 ODR 冲突

// 头文件中的模板函数已隐式 inline，但模板变量需要显式 inline（C++17）
template <typename T>
inline constexpr T pi = T(3.1415926535897932385);

template <typename T>
T circle_area(T r) {
    return pi<T> * r * r;
}

❌ 坏味道

① 模板定义放 .cpp 不实例化

这是新手最常见的错误。模板在 .cpp 中定义，然后在另一个 .cpp 中调用，链接时报"未定义的引用"。

// ❌ bad_template.hpp
template <typename T>
T max(T a, T b);  // 只有声明

// ❌ bad_template.cpp
template <typename T>
T max(T a, T b) { return a > b ? a : b; }  // 定义在 .cpp

// main.cpp：链接错误！找不到 max<int> 的实现

解决方案：将实现放在头文件中，或者在 .cpp 中显式实例化：

// 显式实例化（极少情况下的解决方案）
// math.cpp
template <typename T> T max(T a, T b) { return a > b ? a : b; }
template int max<int>(int, int);        // 显式实例化 int 版本
template double max<double>(double, double);  // 显式实例化 double 版本

② 过度模板元编程

// ❌ 过度使用模板元编程实现简单逻辑
template <int N>
struct IsEven {
    static constexpr bool value = (N % 2 == 0);
};

// ✅ 用 constexpr 函数替代（更可读）
constexpr bool is_even(int n) {
    return n % 2 == 0;
}

③ 不写 typename 导致编译失败

在模板中访问依赖类型必须加 typename 关键字，告诉编译器这是一个类型而非静态成员。

template <typename T>
void foo(const T& container) {
    // ❌ 编译错误：'T::value_type' 被视为值而非类型
    // T::value_type first = *container.begin();

    // ✅ 正确：加 typename
    typename T::value_type first = *container.begin();
}

template <typename T>
class MyClass {
    // ❌ 嵌套模板必须加 template 关键字
    // T::templateMethod<int>();

    // ✅ 正确
    // this->template templateMethod<int>();
};

④ 依赖隐式接口不提约束

// ❌ 没有约束，错误信息极其晦涩
template <typename T>
T multiply(T a, T b) {
    return a * b;  // 如果 T 不支持 operator*，报错在模板内部
}

// ✅ C++20 使用 Concept 提供清晰约束和错误信息
template <typename T>
concept Multiplicable = requires(T a, T b) { { a * b } -> std::convertible_to<T>; };

template <Multiplicable T>
T multiply(T a, T b) { return a * b; }

⑤ 在不需要时使用模板（过度抽象）

// ❌ 不必要的模板化
template <typename T>
struct AlwaysTrue {
    static constexpr bool value = true;
};

// ✅ 直接用 constexpr
constexpr bool always_true = true;

总结

学习路径建议

1. 先掌握函数模板和类模板——和 Java 泛型类似但更灵活
2. 理解"代码生成"而非"类型擦除"——不同的实例化是独立类型
3. 模板错误信息很长——不要慌，通常读第一个和最后一个错误
4. 能用 constexpr 函数解决的，就不要用模板元编程
5. C++20 项目优先使用 Concept 替代 SFINAE
6. 模板代码一定要在头文件中提供完整实现

下一篇文章我们将学习 C++ 的标准模板库（STL），包括容器、算法和迭代器。