C++ 泛型编程

原创已于 2025-11-03 18:54:56 修改 · 773 阅读

30 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #算法 #开发语言

于 2025-09-20 11:00:00 首次发布

编程语言专栏收录该内容

225 篇文章

订阅专栏

一、什么是泛型（Generic Programming）

泛型编程是一种编写与类型无关的代码的方法，使得同一份代码能适用于多种数据类型。C++ 通过模板机制支持泛型编程。

二、C++ 泛型的实现方式 —— 模板（template）

1. 函数模板（Function Template）

函数模板可以生成不同类型的函数版本。

template<typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    std::cout << add(1, 2) << std::endl;     // int
    std::cout << add(1.1, 2.2) << std::endl; // double
}

typename 和 class 关键字等价，均可用于模板参数声明。

2. 类模板（Class Template）

类模板可以生成不同类型的类。

template<typename T>
class Box {
public:
    T value;
    Box(T v) : value(v) {}
    void print() { std::cout << value << std::endl; }
};

int main() {
    Box<int> b1(10);
    b1.print();
    Box<std::string> b2("Hello");
    b2.print();
}

3. 模板的特化（Template Specialization）

（1）全特化

为特定类型实现不同的模板版本。

template<typename T>
class Printer {
public:
    void print(T v) { std::cout << v << std::endl; }
};

template<>
class Printer<char*> {
public:
    void print(char* v) { std::cout << "字符串: " << v << std::endl; }
};

（2）偏特化

对部分模板参数特定化（仅类模板支持）。


template<typename T, typename U>
class Pair {};

template<typename T>
class Pair<T, int> {}; // 第二个参数为int时的特化

4. 非类型模板参数

模板参数不仅可以是类型，还可以是常量。

template<typename T, int N>
class Array {
    T data[N];
};
Array<int, 10> arr; // 10个int的数组

5. 可变参数模板（C++11 起）

支持任意数量的模板参数。

template<typename... Args>
void printAll(Args... args) {
    (std::cout << ... << args) << std::endl; // C++17折叠表达式
}
printAll(1, "abc", 3.14); // 输出: 1abc3.14

6. 模板的默认参数

template<typename T = int>
class MyClass {};
MyClass<> obj; // 等价于 MyClass<int>

三、底层实现原理

编译期生成代码：模板在编译期间实例化（template instantiation），为每种使用到的类型生成独立代码。
类型检查：只有用到的模板实例才会被检查和生成代码。
零运行时开销：模板是编译期机制，不引入运行时性能损耗。

四、泛型的应用场景

STL 容器与算法：如 std::vector<T>、std::sort() 等全部基于模板实现。
通用数据结构和算法：如链表、堆、树、查找、排序等。
数学运算、矩阵库、图像处理库。
工厂模式、策略模式等设计模式的泛型实现。
代码复用和类型安全的抽象。

五、现代 C++ 泛型增强

auto 关键字（C++11）：自动类型推断，配合模板使用更灵活。
decltype、trailing return type：更复杂的类型推断。
Concepts 概念（C++20）：为模板参数增加约束，提高错误提示和类型安全。
std::function、Lambda表达式：配合泛型算法使用。

六、注意事项

模板代码膨胀：每种实例化类型都会生成独立代码，可能导致可执行文件变大。
模板错误信息复杂：编译错误信息常常很长，难以阅读。
分离编译困难：模板定义和实现通常需要放在头文件中。
模板递归和元编程：可以实现复杂的编译期计算，但可读性较差。

七、代码综合示例

#include <iostream>
#include <vector>
#include <algorithm>

template<typename T>
void printVec(const std::vector<T>& v) {
    for (const auto& elem : v)
        std::cout << elem << " ";
    std::cout << std::endl;
}

int main() {
    std::vector<int> vi = {1, 2, 3};
    std::vector<std::string> vs = {"a", "b", "c"};
    printVec(vi);
    printVec(vs);

    // Lambda + 泛型算法
    std::sort(vi.begin(), vi.end(), [](int a, int b) { return a > b; });
    printVec(vi);
}

八、STL 与泛型

C++ 标准模板库（STL）是泛型编程的典范：

容器：std::vector<T>, std::list<T>, std::map<K,V> …
算法：std::sort, std::find_if, std::accumulate …
迭代器、函数对象、适配器等全部基于模板。

九、总结

C++ 泛型编程基于模板机制，是高效代码复用与抽象的核心。
模板支持函数、类、变量、非类型参数、可变参数等高级用法。
现代 C++ 泛型配合 Lambda、auto、Concepts 更加强大灵活。
STL 是泛型编程的最佳实践。

十、深入了解高级泛型技术

模板元编程（Template Metaprogramming）

原理

模板元编程是利用 C++ 模板在编译期进行计算和类型推断。它可以实现类似函数式编程的编译期逻辑，比如条件判断、递归、类型选择等。

典型代码示例：编译期阶乘

template<int N>
struct Factorial {
    static const int value = N * Factorial<N - 1>::value;
};
template<>
struct Factorial<0> {
    static const int value = 1;
};

int main() {
    std::cout << Factorial<5>::value << std::endl; // 输出 120
}

应用场景

编译期常量计算（如数学库、物理仿真）
类型萃取（Type Traits）：判断类型特性
条件选择、类型选择
STL 内部实现（如迭代器类型分析）

现代替代：`constexpr`（C++11）和变量模板（C++14/17）能部分替代传统模板元编程。

Concepts（C++20 概念）

原理

Concepts 是 C++20 引入的一种模板参数约束机制。它能让模板参数更具表达力和类型安全，错误提示更清晰。

代码示例

#include <concepts>
#include <iostream>

template<typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::convertible_to<T>;
};

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

int main() {
    std::cout << add(1, 2) << std::endl;       // OK
    // std::cout << add("a", "b") << std::endl; // 编译报错，string不能直接+
}

应用场景

泛型库开发（如算法库、容器库）
限定模板参数类型能力（如“必须可加”、“必须可迭代”）
错误提示更友好

SFINAE（Substitution Failure Is Not An Error）

原理

SFINAE 是模板参数推断时的一个规则：当模板参数替换失败时，不报错，而是排除该模板重载，继续尝试其它重载。
常用于模板特化、类型萃取和条件编译。

代码示例：检测类型是否有成员函数

#include <type_traits>

template<typename T>
auto has_foo(int) -> decltype(std::declval<T>().foo(), std::true_type{}) {
    return std::true_type{};
}
template<typename T>
std::false_type has_foo(...) { return std::false_type{}; }

struct A { void foo() {} };
struct B {};

int main() {
    std::cout << has_foo<A>(0) << std::endl; // 1
    std::cout << has_foo<B>(0) << std::endl; // 0
}

应用场景

条件启用函数/类（如 enable_if）
类型萃取（Type Traits）
泛型编程中的自动选择最佳实现

CRTP（Curiously Recurring Template Pattern）

原理

CRTP 是一种模板继承模式，让基类依赖于派生类类型，从而实现静态多态、编译期优化等。

代码示例

#include <iostream>

template<typename Derived>
class Base {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

class Derived : public Base<Derived> {
public:
    void implementation() {
        std::cout << "Derived implementation\n";
    }
};

int main() {
    Derived d;
    d.interface(); // 输出 Derived implementation
}

应用场景

静态多态（无需虚函数，编译期决议）
CRTP 用于 STL、Eigen、Boost 等库的表达式模板优化
代码复用（如“混入”模式）

综合应用场景

STL：大量使用 SFINAE、Type Traits、CRTP 实现高效容器和算法。
数学库：模板元编程和 CRTP 实现表达式模板，极大提高性能。
泛型算法库：Concepts 限定参数类型，SFINAE 自动选择实现。
类型萃取：如 std::is_integral<T>, std::enable_if, std::conditional。

现代 C++ 泛型技术建议

优先用 constexpr 实现编译期计算，简化代码。
用 Concepts 限定模板参数类型，提升安全性。
用 SFINAE/Type Traits 实现条件编译和类型萃取。
用 CRTP 实现静态多态、表达式模板优化。
复杂元编程建议用 std::tuple、std::variant、std::optional 等现代类型辅助。

参考代码：表达式模板（CRTP + 元编程）

#include <iostream>

template<typename Derived>
struct Expr {
    double eval() const { return static_cast<const Derived*>(this)->eval(); }
};

struct Var : Expr<Var> {
    double value;
    Var(double v) : value(v) {}
    double eval() const { return value; }
};

template<typename L, typename R>
struct Add : Expr<Add<L, R>> {
    L l; R r;
    Add(L l_, R r_) : l(l_), r(r_) {}
    double eval() const { return l.eval() + r.eval(); }
};

int main() {
    Var x(2.5), y(3.5);
    Add<Var, Var> expr(x, y);
    std::cout << expr.eval() << std::endl; // 输出 6
}

创作不易，点赞关注，持续更新！！！