编辑“︁泛型编程”︁（章节）

= 泛型编程 =

'''泛型编程'''是一种编程范式，它允许开发者编写与特定数据类型无关的代码，从而提高代码的复用性和灵活性。在[[C++]]中，泛型编程主要通过'''模板'''机制实现，这也是[[标准模板库]](STL)的基础。

== 概述 ==

泛型编程的核心思想是编写可以处理多种数据类型的代码，而不需要为每种类型都重写相同的逻辑。这种编程方式与传统的面向对象编程不同，它是在编译时而非运行时进行类型处理，因此能够提供更好的性能。

泛型编程的主要优点包括：
* '''代码复用'''：同一套算法可以应用于不同的数据类型
* '''类型安全'''：编译时进行类型检查，减少运行时错误
* '''性能优势'''：避免了运行时类型检查和转换的开销

== C++中的实现 ==

在[[C++]]中，泛型编程主要通过两种模板实现：

=== 函数模板 ===

函数模板允许定义可以处理多种类型的函数：

<syntaxhighlight lang="cpp">
template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

// 使用示例
int main() {
    std::cout << max(3, 5) << std::endl;      // 输出: 5
    std::cout << max(3.14, 2.71) << std::endl; // 输出: 3.14
    std::cout << max('a', 'z') << std::endl;   // 输出: z
}
</syntaxhighlight>

=== 类模板 ===

类模板允许定义可以处理多种类型的类：

<syntaxhighlight lang="cpp">
template <typename T>
class Box {
private:
    T content;
public:
    void set(T value) { content = value; }
    T get() { return content; }
};

// 使用示例
int main() {
    Box<int> intBox;
    intBox.set(42);
    std::cout << intBox.get() << std::endl;  // 输出: 42

    Box<std::string> strBox;
    strBox.set("Hello");
    std::cout << strBox.get() << std::endl;  // 输出: Hello
}
</syntaxhighlight>

== 标准模板库(STL) ==

[[标准模板库]]是C++中泛型编程的最佳实践，它由三大部分组成：

1. '''容器'''：如vector、list、map等
2. '''算法'''：如sort、find、transform等
3. '''迭代器'''：作为容器和算法之间的桥梁

<syntaxhighlight lang="cpp">
#include <vector>
#include <algorithm>
#include <iostream>

int main() {
    std::vector<int> numbers = {5, 2, 8, 1, 9};
    
    // 使用泛型算法排序
    std::sort(numbers.begin(), numbers.end());
    
    // 输出结果
    for (int num : numbers) {
        std::cout << num << " ";
    }
    // 输出: 1 2 5 8 9
}
</syntaxhighlight>

== 高级特性 ==

=== 模板特化 ===

可以为特定类型提供模板的特殊实现：

<syntaxhighlight lang="cpp">
template <typename T>
class Printer {
public:
    void print(T value) {
        std::cout << "通用打印: " << value << std::endl;
    }
};

// 对char*类型的特化
template <>
class Printer<const char*> {
public:
    void print(const char* value) {
        std::cout << "字符串打印: " << value << std::endl;
    }
};
</syntaxhighlight>

=== 可变参数模板 ===

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

<syntaxhighlight lang="cpp">
template <typename... Args>
void printAll(Args... args) {
    (std::cout << ... << args) << std::endl;  // C++17折叠表达式
}

int main() {
    printAll(1, " ", 2.5, " ", 'a');  // 输出: 1 2.5 a
}
</syntaxhighlight>

== 实际应用案例 ==

=== 通用数据结构 ===

泛型编程常用于实现与数据类型无关的数据结构：

<syntaxhighlight lang="cpp">
template <typename T>
class Stack {
private:
    std::vector<T> elements;
public:
    void push(T const& elem) {
        elements.push_back(elem);
    }
    void pop() {
        if (elements.empty())
            throw std::out_of_range("Stack<>::pop(): empty stack");
        elements.pop_back();
    }
    T top() const {
        if (elements.empty())
            throw std::out_of_range("Stack<>::top(): empty stack");
        return elements.back();
    }
};
</syntaxhighlight>

=== 算法抽象 ===

泛型算法可以应用于各种容器：

<syntaxhighlight lang="cpp">
template <typename Iterator, typename Predicate>
Iterator find_if(Iterator first, Iterator last, Predicate pred) {
    while (first != last) {
        if (pred(*first)) return first;
        ++first;
    }
    return last;
}

// 使用示例
bool isEven(int n) { return n % 2 == 0; }

int main() {
    std::vector<int> v = {1, 3, 5, 2, 4};
    auto it = find_if(v.begin(), v.end(), isEven);
    if (it != v.end())
        std::cout << "第一个偶数是: " << *it << std::endl;
}
</syntaxhighlight>

== 与其他语言的比较 ==

* '''Java泛型'''：使用类型擦除实现，运行时无类型信息
* '''C#泛型'''：与C++类似，但运行时有类型信息
* '''Rust泛型'''：结合了特质(trait)系统，提供更强大的抽象能力

== 优缺点 ==

=== 优点 ===
* 提高代码复用性
* 增强类型安全性
* 减少代码重复
* 提高性能（编译时解析）

=== 缺点 ===
* 编译错误信息可能难以理解
* 可能增加编译时间
* 模板代码调试较困难

== 未来发展 ==

C++20引入了'''概念(Concepts)'''，进一步增强了泛型编程的能力：

<syntaxhighlight lang="cpp">
template <typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::same_as<T>;
};

template <Addable T>
T sum(T a, T b) {
    return a + b;
}
</syntaxhighlight>

== 参见 ==

* [[模板元编程]]
* [[标准模板库]]
* [[C++]]
* [[面向对象编程]]
* [[函数式编程]]

[[Category:编程范式]]
[[Category:C++]]
[[Category:计算机科学概念]]