C++函数模板精通：泛型编程的5大应用与实践技巧

# 1. C++函数模板概述

C++函数模板是泛型编程的基础，它允许我们编写与数据类型无关的代码。通过函数模板，我们能够创建具有参数化类型的通用函数，这些函数可以适应不同的数据类型，而无需重写相同的逻辑。例如，一个交换两个变量值的函数可以通过模板实现，从而支持整型、浮点型甚至自定义类型。

函数模板的定义类似于普通函数，但使用类型参数而非具体数据类型。编译器会根据函数调用时提供的参数类型，自动实例化对应的函数版本。这种机制不仅减少了代码的重复性，而且提高了代码的可维护性和扩展性。

在本章中，我们将了解函数模板的基本概念，学习如何定义和使用它们，并探讨它们在代码中的实际应用。接下来，我们将深入探讨函数模板的高级特性，了解如何进行模板特化以及如何利用非类型模板参数，从而让模板编程变得更加灵活和强大。

# 2. 深入理解函数模板

## 2.1 函数模板的基础语法

### 2.1.1 定义和实例化

函数模板是C++中支持泛型编程的重要特性之一。它允许程序员编写与类型无关的代码，这意味着同样的代码可以用于多种数据类型。函数模板的定义以关键字`template`开始，后跟模板参数列表。模板参数列表是一个由尖括号`<>`包围的逗号分隔的列表，其中包含了模板类型参数。

下面是一个简单的函数模板示例，用于交换两个变量的值：

template <typename T>
void swap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

在这个例子中，`T`是一个类型参数，它在模板实例化时会被具体的类型替代。当我们调用`swap`函数并传递具体类型的参数时，编译器会自动创建模板的一个实例。

例如，使用整型和浮点型调用`swap`函数，代码如下：

int main() {
    int i = 1, j = 2;
    swap(i, j); // 实例化为void swap(int& a, int& b)
    double x = 1.1, y = 2.2;
    swap(x, y); // 实例化为void swap(double& a, double& b)
    return 0;
}

实例化过程中，编译器将模板参数`T`替换为`int`和`double`，生成两个不同的函数。

### 2.1.2 类型参数化与编译过程

函数模板的类型参数化是其核心特性之一。通过参数化类型，可以编写出通用的算法和数据结构，避免为每一种数据类型编写重复的代码。类型参数化不仅可以提高代码的复用性，还能够增强代码的可维护性。

编译器在处理函数模板时，并不会为每个可能的类型生成一个独立的函数版本。相反，它会在编译时将模板代码和实际类型参数进行实例化。这一过程被称为模板实例化。它包括两个阶段：模板编译和模板实例化。

- 模板编译（模板解析）：编译器在第一次遇到模板定义时，会检查模板的语法正确性，但不会生成实际的机器代码。
- 模板实例化：当模板函数被调用时，编译器会根据实际的类型参数生成特定的函数版本。

例如，考虑以下模板函数：

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

当我们使用不同的类型调用`add`函数时，编译器会产生两个实例化的函数：

int result_int = add(1, 2); // 实例化为int add(int, int)
double result_double = add(1.1, 2.2); // 实例化为double add(double, double)

在模板编译阶段，编译器验证模板函数的语法正确性。随后，在实例化阶段，编译器根据使用的具体类型生成函数的机器代码。这个过程也被称为模板代码的"延迟编译"特性。

由于函数模板的这种特性，模板代码通常位于头文件中，以确保在包含头文件的所有编译单元中都可以进行实例化。

## 2.2 函数模板的高级特性

### 2.2.1 模板特化

在某些情况下，我们可能希望针对特定类型提供不同的实现。C++支持模板特化，允许程序员为特定类型提供专门的模板实现。模板特化可以是全特化，也可以是部分特化。

全特化提供了一个完全确定的类型，替换所有模板参数：

template <>
void swap<int>(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

在这个全特化版本中，`swap`函数对于`int`类型被特别实现。当我们对`int`类型的变量使用`swap`函数时，编译器将使用这个特化版本。

部分特化则提供了一种类型或几种类型的专门实现，但不是全部：

template <typename T>
void process(T& t, int n) {
    // 通用实现
}

template <typename T>
void process(T& t, const char* s) {
    // 针对字符指针的特殊实现
}

在这里，我们定义了一个通用的`process`函数模板，并对字符指针类型`const char*`进行了部分特化，提供了一个专门的实现。

### 2.2.2 非类型模板参数

非类型模板参数指的是模板参数列表中不涉及类型的参数。这些参数在编译时必须是常量表达式。非类型模板参数可以是整型、枚举类型、指向对象或函数的指针、指向成员的指针或引用等。

例如，我们可以创建一个固定大小的数组模板，通过非类型模板参数指定数组的大小：

template <size_t N>
class FixedArray {
private:
    int data[N];
public:
    void set(int value) {
        for (size_t i = 0; i < N; ++i)
            data[i] = value;
    }
    int get(size_t index) const {
        return data[index];
    }
};

在这个例子中，`N`是一个非类型模板参数，用于指定数组的大小。我们可以在编译时知道数组的大小，因此这是一个合理的使用场景。

### 2.2.3 模板参数的默认值

模板参数可以有默认值，这为模板提供了额外的灵活性。当调用模板函数或实例化模板类时，如果没有指定某个模板参数，编译器将使用默认值。

例如，我们可以为函数模板提供默认参数，以支持不同类型的迭代器：

template <typename Iterator = std::vector<int>::iterator>
void process(Iterator begin, Iterator end) {
    // 处理迭代器范围内的元素
}

在这个例子中，如果没有为`process`函数提供迭代器类型，它将默认使用`std::vector<int>::iterator`。这样，我们可以用不同的迭代器类型来调用这个函数，如`std::list<int>::iterator`或者`int*`。

## 2.3 模板与重载解析

### 2.3.1 重载决议中的优先级

函数重载是一种多态形式，允许使用相同的函数名调用不同实现的函数。当使用函数模板时，可能会出现与常规函数或者重载函数的调用冲突，这种情况下需要进行重载决议。

C++标准指定了重载解析的规则，其中包括对模板函数和非模板函数之间优先级的规定。一般来说，非模板函数的优先级高于模板函数，除非模板函数提供了更好的匹配。

例如，考虑以下函数：

void foo(int);
template <typename T>
void foo(T);

如果调用`foo(1)`，编译器会选择`void foo(int);`，因为它比模板函数提供了一个精确的匹配。而对于`foo('1')`，由于字符常量在`foo(int)`中需要进行类型提升，编译器则会匹配到模板函数`void foo(T);`。

### 2.3.2 模板与非模板函数的匹配规则

当模板函数与非模板函数同时存在时，编译器会应用以下匹配规则：

1. 如果模板函数和非模板函数都可以被调用，则优先选择非模板函数。
2. 如果模板函数提供了一个更接近的匹配，则会选择模板函数。

考虑下面的例子：

void foo(double);

template <typename T>
void foo(T);

foo(1.1); // 调用foo(double)

对于调用`foo(1.1)`，虽然模板函数也能匹配，但非模板函数提供了一个精确匹配，所以非模板函数被优先选择。

在某些情况下，可能需要明确地实例化一个模板函数，或者使用模板类型转换来指定模板参数，以保证模板函数被正确选择：

template <typename T>
void foo(T);

foo<int>(1.1); // 使用模板类型转换

在这个例子中，通过指定模板参数`int`，我们明确地实例化了`foo<int>`，从而避免了与非模板函数的冲突。

在选择使用模板还是非模板函数时，需要仔细考虑匹配规则和函数的可访问性。这可以通过对函数名称进行限定或者调整函数声明来实现。

### 2.3.3 实例化控制与编译时错误

控制模板实例化对于减少编译时间、避免不必要的编译错误和避免代码膨胀非常有用。在复杂的模板编程中，不当的实例化可能导致难以追踪的错误，因此，显式控制模板实例化是一个最佳实践。

例如，我们可以把模板函数的定义放在头文件中，但声明放在源文件中：

// 模板声明
template <typename T>
void foo(T);

// 实际定义
template <typename T>
void foo(T) {
    // 实现细节
}

在源文件中，只有当函数`foo`被显式调用时，模板才会实例化，否则不会产生编译时错误。这样可以避免因为错误的模板实例化而导致整个编译失败。

此外，C++11标准引入了外部模板（extern template）声明，允许程序员显式地防止模板的实例化：

extern template class std::vector<int>; // 显式地防止std::vector<int>的实例化

在链接阶段，如果存在未实例化的模板定义，链接器将会报错，因为模板函数必须在每个使用它的编译单元中被实例化。

通过控制模板实例化的时机，我们可以优化编译过程，提高编译器的效率，并减少编译错误的可能性。

# 3. 泛型编程的实践应用

## 3.1 标准库中的函数模板应用

### 3.1.1 STL算法与函数对象

在C++标准库中，模板技术被广泛应用，尤其是在STL（Standard Template Library）算法和函数对象上。STL算法是处理序列数据的一系列模板函数，而函数对象则是封装了操作的模板类，它们可以像函数一样被调用。这为泛型编程提供了极大的便利和强大的功能。

STL算法如 `std::sort`, `std::find`, `std::for_each` 等，通过模板参数化，可以操作不同类型的容器，例如`std::vector`, `std::list`, `std::set`等，无需为每种容器和数据类型重写算法，实现了高度的代码复用。STL算法的强大之处在于它们与迭代器概念的结合，迭代器允许算法与容器解耦，这样就可以在不关心容器具体实现的情况下，操作容器中的数据。

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

int main() {
    std::vector<int> nums = {5, 3, 7, 2, 8};

    // 使用STL算法std::sort对整数向量进行排序
    std::sort(nums.begin(), nums.end());

    // 使用STL算法std::for_each来打印每个元素
    std::for_each(nums.begin(), nums.end(), [](int n) {
        std::cout << n << " ";
    });

    return 0;
}

在此示例中，`std::sort` 函数模板接受两个迭代器作为参数，分别指向要排序的序列的起始和结束位置。`std::for_each`函数模板接受一个范围的迭代器和一个函数对象（这里使用lambda表达式），并将其应用于该范围内的每个元素。

### 3.1.2 容器与迭代器

容器是泛型编程的核心组成部分之一，它们用于存储和管理集合中的数据。容器通过模板参数化实现其通用性。C++标准库提供了多种容器，如`vector`, `list`, `map`, `set`等。这些容器不仅能够存储数据，还提供了丰富的方法和操作来进行数据的插入、删除和访问。

迭代器是连接算法与容器的桥梁，它们提供了类似于指针的操作，用于遍历容器中的元素。迭代器是容器的内部实现细节，标准库容器几乎都提供了相应的迭代器类型，如`std::vector<T>::iterator`。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 使用迭代器遍历vector容器
    for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }

    return 0;
}

在这个例子中，我们使用`std::vector<int>::iterator`来遍历一个整数向量。迭代器是通过`vec.begin()`和`vec.end()`获取的，分别代表容器中第一个元素的迭代器和容器末尾的迭代器。

通过容器和迭代器，我们能够编写出既通用又高效的代码，这正是泛型编程的目标所在。通过模板技术，C++提供了一种强大的方式来创建灵活和可重用的代码库，使得开发人员能够专注于解决问题的逻辑，而不是数据类型的具体细节。

## 3.2 自定义数据结构的泛型实现

### 3.2.1 泛型链表与数组实现

泛型编程不仅适用于标准库，它也鼓励我们自定义数据结构，以提供更加强大和灵活的解决方案。泛型链表和泛型数组是两种常见的数据结构实现，它们通过模板参数化来实现类型安全且可重用的代码。

在自定义泛型链表时，节点通常会包含数据和指向下一个节点的链接，数据类型则由模板参数确定。泛型链表的实现需要考虑节点的添加、删除、遍历等操作，并且能够处理不同数据类型。

template<typename T>
struct Node {
    T data;
    Node<T>* next;
};

template<typename T>
class LinkedList {
public:
    Node<T>* head;

    LinkedList() : head(nullptr) {}

    // 向链表头部添加元素
    void push_front(const T& data) {
        Node<T>* node = new Node<T>{data, head};
        head = node;
    }

    // 遍历链表并打印元素
    void display() const {
        Node<T>* current = head;
        while (current != nullptr) {
            std::cout << current->data << " ";
            current = current->next;
        }
        std::cout << std::endl;
    }
};

泛型数组的实现需要考虑内存的动态分配和数组大小的动态调整。使用模板，可以创建一个能够存储任意类型元素的数组，并在运行时根据需求动态增长和缩减。

template<typename T>
class DynamicArray {
private:
    T* array;
    size_t size;

public:
    DynamicArray() : array(nullptr), size(0) {}

    // 构造函数，初始化数组大小
    DynamicArray(size_t initialSize) : size(initialSize) {
        array = new T[size];
    }

    // 析构函数，释放动态分配的内存
    ~DynamicArray() {
        delete[] array;
    }

    // 其他成员函数...
};

上述两个例子展示了如何通过模板创建具有泛型特性的链表和数组。泛型数据结构是泛型编程中非常实用的一环，通过模板，我们可以轻松地为多种数据类型实现功能丰富的数据结构。

### 3.2.2 泛型栈与队列

栈和队列是两种常见的数据结构，在数据处理中占有重要地位。泛型栈和泛型队列的实现类似于链表，但它们的内部操作和数据流动有所不同。栈是一种后进先出（LIFO）的数据结构，而队列是一种先进先出（FIFO）的数据结构。

泛型栈可以通过模板实现，使其能够处理任何类型的数据。栈通常需要进行压栈（push）、弹栈（pop）、查看栈顶元素（top）等操作。

template<typename T>
class Stack {
private:
    std::vector<T> data;

public:
    void push(const T& element) {
        data.push_back(element);
    }

    T pop() {
        if (data.empty()) {
            throw std::out_of_range("Stack<>::pop(): empty stack");
        }
        T result = data.back();
        data.pop_back();
        return result;
    }

    T top() const {
        if (data.empty()) {
            throw std::out_of_range("Stack<>::top(): empty stack");
        }
        return data.back();
    }
};

队列可以使用模板进行实现，允许用户存储和管理数据集合。队列支持两种主要操作：入队（enqueue）和出队（dequeue）。入队操作将新元素添加到队列的末尾，而出队操作从队列的开头移除元素。

template<typename T>
class Queue {
private:
    std::list<T> data;

public:
    void enqueue(const T& element) {
        data.push_back(element);
    }

    T dequeue() {
        if (data.empty()) {
            throw std::out_of_range("Queue<>::dequeue(): empty queue");
        }
        T result = data.front();
        data.pop_front();
        return result;
    }

    size_t size() const {
        return data.size();
    }
};

泛型栈和泛型队列的实现使得我们可以轻松地对各种数据进行后进先出或先进先出的处理。这些数据结构的模板化实现是泛型编程原则的典型应用，能够有效地增强代码的复用性和灵活性。

## 3.3 性能优化与编译器特性

### 3.3.1 模板代码的优化技巧

泛型编程的性能优化是一个复杂的议题，特别是在模板代码中。由于模板的实例化特性，合理的优化对于提高程序性能至关重要。编写高效的模板代码要求开发者了解编译器的工作方式，以及如何影响编译器的行为来实现优化。

一个重要的优化技巧是避免不必要的模板实例化。模板的每个实例化都需要编译器生成相应的代码，因此减少实例化数量可以有效减少编译时间，并可能提高运行时性能。这可以通过模板特化来实现，将常见的特定情况作为特化版本来处理，从而减少实例化。

另一个优化策略是减少模板函数的开销。通过使用内联函数、减少循环展开，以及通过减少模板函数中的虚函数调用，可以进一步提高性能。

// 示例：内联函数减少调用开销
template <typename T>
inline T max(const T& a, const T& b) {
    return a > b ? a : b;
}

此外，模板代码的优化还包括对模板类中成员函数的优化，以及对于模板算法的优化。合理使用STL容器和算法，选择适当的容器和算法来匹配特定的应用场景，可以显著提高程序效率。

### 3.3.2 编译器对模板的支持与限制

编译器对模板的支持是C++模板编程的核心。现代C++编译器提供了强大的模板处理能力，能够处理复杂的模板代码。尽管如此，模板编程仍然有一定的限制和挑战。

编译器在处理模板时面临的一个问题是错误信息难以理解。模板错误通常涉及模板代码的多个部分，可能产生冗长和难以追踪的编译器错误信息。因此，编写清晰、逻辑分离良好的模板代码对于问题诊断至关重要。

// 例子：使用SFINAE（Substitution Failure Is Not An Error）原则优化编译器错误信息
template <typename T, typename = void>
struct has_begin_end : std::false_type {};

template <typename T>
struct has_begin_end<T, std::void_t<decltype(std::declval<T>().begin()), decltype(std::declval<T>().end())>> : std::true_type {};

// 使用
template <typename T>
void someFunction(T& container) {
    if constexpr (has_begin_end<T>::value) {
        // 容器有begin和end，则可以遍历
        for (auto it = container.begin(); it != container.end(); ++it) {
            // ...
        }
    } else {
        // 容器没有begin和end，进行其他操作
        // ...
    }
}

在上面的代码中，`has_begin_end`模板结构利用SFINAE原则检测一个类型是否有`begin`和`end`成员函数。这样做可以在编译时得到关于类型是否可以迭代的有用信息，有助于编写更加健壮和清晰的模板代码。

另一个编译器支持的特性是编译时计算，它可以用于模板编程中优化数据结构和算法。编译时计算允许在编译阶段完成一些工作，这通常可以提升运行时性能，因为某些计算可以在程序执行前就已经被解决。

// 编译时计算的例子：编译时求阶乘
template <size_t n>
struct Factorial {
    static constexpr size_t value = n * Factorial<n - 1>::value;
};

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

// 使用
constexpr size_t result = Factorial<5>::value; // 结果为120

在上面的例子中，我们定义了一个递归模板结构来计算阶乘。这个模板在编译时就已经解决，结果被编码为一个编译时常量。通过这种方式，我们可以预先计算那些对运行时性能有重大影响的值，以避免运行时的计算开销。

总之，模板编程需要开发者了解编译器如何处理模板，以及如何利用编译器的特性来优化模板代码。通过减少不必要的模板实例化，优化模板函数，并利用编译器的强大特性，可以实现高效且稳定的泛型编程解决方案。

# 4. C++11及以上版本的模板新特性

## 4.1 可变参数模板

### 4.1.1 可变参数模板的定义与应用

可变参数模板（Variadic Templates）是C++11引入的一项强大特性，允许函数或类接受不定数量的模板参数。这种能力特别适用于需要处理任意数量参数或类型不同的情况，如日志记录、格式化输出等。

定义可变参数模板，使用省略号（...）语法，它表示模板参数包。参数包可以是类型参数包或非类型参数包。

template<typename ...Args> void func(Args... args) {
    // 处理参数包
}

调用此类模板时，可以传递任意数量的参数：

func(1, "text", 3.14);

编译器会为每个调用生成一个特化版本，这是一个称为模板递归的过程。

可变参数模板在实际编程中的应用广泛。一个常见的用途是创建类型安全的“printf”风格的函数，称为print系列函数。

### 4.1.2 编译时序列操作与折叠表达式

C++17增强了对可变参数模板的操作，引入了折叠表达式（Fold Expressions）。通过折叠表达式可以简化对参数包的处理，将操作符应用于参数包中的所有元素。

例如，使用加号折叠来计算参数包中所有元素的和：

template<typename ...Args> auto sum(Args... args) {
    return (... + args); // 使用折叠表达式
}

编译时，这个表达式会展开成：

((args1 + args2) + args3) + ... + argsN

折叠表达式不仅限于加法，也支持其他操作符，如乘法(*)、逻辑与(&&)、逻辑或(||)等。这样的特性使得我们可以创建更加灵活的编译时计算。

## 4.2 类型萃取与模板元编程

### 4.2.1 类型萃取技术

类型萃取（Type Traits）是C++模板编程中的另一个重要概念，它允许在编译时检查和处理类型。C++标准库中的`<type_traits>`提供了丰富的类型萃取工具，例如：

- `std::is_same<T1, T2>`：检查两种类型是否相同。
- `std::enable_if`：条件性启用或禁用模板实例。
- `std::remove_reference`：移除类型引用。

类型萃取在编译时进行计算，无需运行时开销，非常适合于模板元编程。类型萃取对于优化模板函数和类的行为至关重要，如条件编译、模板特化等。

### 4.2.2 模板元编程的基本概念

模板元编程（Template Metaprogramming）是在编译时进行的一系列计算，它利用了模板和类型萃取。模板元编程可以在不产生实际代码的情况下，在编译阶段完成复杂的计算任务，优化最终生成的机器码。

例如，编译时计算斐波那契数列：

template<int N> struct Fibonacci {
    static const int value = Fibonacci<N-1>::value + Fibonacci<N-2>::value;
};
template<> struct Fibonacci<0> { static const int value = 0; };
template<> struct Fibonacci<1> { static const int value = 1; };

这里，我们定义了一个模板结构`Fibonacci`，它将递归计算斐波那契数列的第N项。这个元程序在编译时执行，而生成的程序仅包含对`value`的直接引用。

模板元编程广泛应用于高性能计算领域，它通过编译时计算减少了运行时开销，提高了程序效率。

## 4.3 模板编译模型改进

### 4.3.1 外部模板与编译时间优化

C++11引入的外部模板（External Templates）特性允许开发者明确指出一个模板是否应该被实例化。通过显式实例化或抑制实例化，可以优化编译时间。

显式实例化告诉编译器对于某个模板特化应该生成代码，可以这样使用：

template class std::vector<int>; // 显式实例化

抑制实例化可以避免不必要的模板实例化，减少编译时间：

extern template class std::vector<double>; // 抑制实例化

### 4.3.2 模块化编程与模块接口

模块化编程是C++20标准中引入的一个重要特性，它允许将代码划分为多个模块。每个模块可以有自己的接口和实现，从而提高编译效率和代码的组织性。

模块使用`module`关键字声明：

module MyModule;

export template <typename T>
class MyVector {
    // ...
};

模块允许编译器只编译与所更改部分相关的代码，而不是整个项目，这在大型项目中可以显著提高编译速度。

模块化编程改变代码的导入方式，使用`import`关键字代替传统的头文件包含。这种方式避免了头文件依赖循环，且模块可以具有更好的封装性。

这一节展示了C++11及以后版本为模板编程带来的新特性和改进。随着编译器对这些特性的支持逐渐增强，它们在现代C++开发中扮演着越来越重要的角色。

# 5. 函数模板进阶技巧与案例分析

## 5.1 泛型编程的设计模式

### 5.1.1 适配器模式与策略模式

在C++中，模板不仅用于函数，还可以用于类，为泛型编程提供了强大的灵活性。通过使用泛型设计模式，可以将模板的通用性与设计模式的灵活性结合，创建出既通用又可复用的代码库。

适配器模式是一种结构型设计模式，它允许将一个类的接口转换成客户端期望的另一个接口。通过模板实现的泛型适配器模式可以将一个类的接口适配到其他接口，从而使得接口不兼容的类能够协同工作。

template <typename T>
class Adapter {
public:
    Adapter(T adaptee) : adaptee_(adaptee) {}
    // 转换接口
    void request() {
        adaptee_.specificRequest();
    }
private:
    T adaptee_;
};

class ClientInterface {
public:
    virtual void request() = 0;
    virtual ~ClientInterface() {}
};

class Adaptee {
public:
    void specificRequest() {
        std::cout << "Adaptee Specific Request" << std::endl;
    }
};

int main() {
    Adaptee adaptee;
    Adapter<Adaptee> adapter(adaptee);
    adapter.request();
    return 0;
}

策略模式是一种行为型设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以互相替换。通过模板实现的策略模式允许在运行时选择算法的实现，从而使算法可以独立于使用它的客户端变化。

template <typename T, typename Strategy>
class Context {
public:
    void executeStrategy(T data) {
        strategy_.doOperation(data);
    }
private:
    Strategy strategy_;
};

class ConcreteStrategyA {
public:
    void doOperation(int data) {
        std::cout << "ConcreteStrategyA: " << data << std::endl;
    }
};

class ConcreteStrategyB {
public:
    void doOperation(int data) {
        std::cout << "ConcreteStrategyB: " << data << std::endl;
    }
};

int main() {
    Context<int, ConcreteStrategyA> context;
    context.executeStrategy(10);
    context.executeStrategy(20);
    return 0;
}

通过适配器模式和策略模式，我们可以编写更加灵活、可扩展和可维护的代码。这些模式通过模板类的泛型特性，能够提供强大的类型安全和接口抽象，使得代码更加健壮和易于使用。