C++教程 第19章 模板和泛型编程

第19章 模板和泛型编程

模板的底层实现原理

模板实例化机制

模板是C++中实现泛型编程的核心机制，其底层实现涉及编译期实例化过程：

1. 模板定义：编译器解析模板代码，但不生成具体代码
2. 实例化触发：当模板被使用时（如创建对象或调用函数）
3. 类型替换：编译器将模板参数替换为具体类型
4. 代码生成：为每个唯一的模板实例生成专门的代码
5. 优化：对生成的代码应用常规编译优化

模板实例化的编译器处理

// 模板定义
template <typename T>
T maximum(T a, T b) {
    return a > b ? a : b;
}

// 实例化触发
int main() {
    int a = 1, b = 2;
    double c = 1.5, d = 2.5;
    
    // 触发 int 版本的实例化
    int max_int = maximum(a, b);
    
    // 触发 double 版本的实例化
    double max_double = maximum(c, d);
    
    return 0;
}

编译器会为 maximum<int> 和 maximum<double> 生成两个不同的函数实例，每个实例都是针对具体类型优化的代码。

模板的名称查找规则

1. 依赖名称查找（ADL）：模板中的依赖名称会在实例化时查找
2. 两阶段查找：
   • 第一阶段：解析模板时，查找非依赖名称
   • 第二阶段：实例化时，查找依赖名称
3. 模板参数推导：编译器根据实参类型推导模板参数类型

高级模板元编程

编译期计算

// 编译期计算阶乘
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;
};

// 使用编译期计算
constexpr unsigned int fact_5 = Factorial<5>::value; // 编译期计算为 120

类型 traits

// 自定义类型 trait
template <typename T>
struct is_integral {
    static constexpr bool value = false;
};

// 特化基本整型
template <>
struct is_integral<int> {
    static constexpr bool value = true;
};

template <>
struct is_integral<long> {
    static constexpr bool value = true;
};

// 使用类型 trait
template <typename T>
void process(T value) {
    if constexpr (is_integral<T>::value) {
        std::cout << "Processing integral type: " << value << std::endl;
    } else {
        std::cout << "Processing non-integral type" << std::endl;
    }
}

SFINAE 技术

// SFINAE: Substitution Failure Is Not An Error
template <typename T>
auto test(T t) -> decltype(t.foo(), std::true_type()) {
    return std::true_type{};
}

template <typename T>
std::false_type test(...);

template <typename T>
struct has_foo : decltype(test<T>(std::declval<T>())) {
};

// 使用 SFINAE
template <typename T>
void process_if_has_foo(T t) {
    if constexpr (has_foo<T>::value) {
        t.foo();
    } else {
        std::cout << "Type does not have foo() method" << std::endl;
    }
}

模板元编程的实际应用

编译期反射

#include <iostream>
#include <vector>

// 编译期类型信息获取
template <typename T>
struct TypeInfo {
    static constexpr const char* name() {
        return "unknown";
    }
};

// 特化基本类型
template <>
struct TypeInfo<int> {
    static constexpr const char* name() {
        return "int";
    }
};

template <>
struct TypeInfo<double> {
    static constexpr const char* name() {
        return "double";
    }
};

template <typename T>
struct TypeInfo<std::vector<T>> {
    static constexpr const char* name() {
        return "std::vector<>";
    }
};

// 使用类型信息
template <typename T>
void printTypeInfo() {
    std::cout << "Type: " << TypeInfo<T>::name() << std::endl;
}

constexpr 函数的高级应用

// 编译期字符串长度计算
constexpr size_t strlen_constexpr(const char* str) {
    return *str ? 1 + strlen_constexpr(str + 1) : 0;
}

// 编译期字符串比较
constexpr bool strcmp_constexpr(const char* a, const char* b) {
    return *a == *b && (*a == '\0' || strcmp_constexpr(a + 1, b + 1));
}

// 编译期字符串哈希
constexpr size_t hash_string(const char* str, size_t seed = 0) {
    return *str ? hash_string(str + 1, seed * 31 + *str) : seed;
}

可变参数模板

可变参数模板是C++11引入的重要特性，它允许模板接受任意数量的模板参数：

// 可变参数模板的基本形式
template <typename... Args>
void print(Args... args) {
    // 处理可变参数
}

// 递归展开可变参数
template <typename T>
void print_single(T t) {
    std::cout << t << std::endl;
}

template <typename T, typename... Args>
void print(T first, Args... rest) {
    print_single(first);
    print(rest...); // 递归调用
}

// 使用折叠表达式（C++17+）
template <typename... Args>
void print_fold(Args... args) {
    (std::cout << ... << args) << std::endl;
}

// 带分隔符的折叠表达式
template <typename... Args>
void print_with_separator(Args... args) {
    ((std::cout << args << ", "), ...);
    std::cout << std::endl;
}

模板模板参数

模板模板参数允许将模板作为另一个模板的参数：

// 模板模板参数的基本形式
template <template <typename> class Container, typename T>
void process_container(Container<T>& container) {
    for (auto& item : container) {
        std::cout << item << " ";
    }
    std::cout << std::endl;
}

// 使用标准容器
template <template <typename, typename> class Container, typename T, typename Allocator>
void process_std_container(Container<T, Allocator>& container) {
    for (auto& item : container) {
        std::cout << item << " ";
    }
    std::cout << std::endl;
}

// 实际使用
std::vector<int> vec = {1, 2, 3, 4, 5};
std::list<double> lst = {1.1, 2.2, 3.3};

process_std_container(vec); // 处理vector
process_std_container(lst); // 处理list

别名模板

别名模板是C++11引入的特性，它允许为模板创建别名：

// 基本别名模板
template <typename T>
using Vec = std::vector<T>;

// 使用别名模板
Vec<int> int_vector = {1, 2, 3};
Vec<double> double_vector = {1.1, 2.2, 3.3};

// 带默认参数的别名模板
template <typename T = int>
using Matrix = std::vector<std::vector<T>>;

// 使用带默认参数的别名模板
Matrix<> int_matrix; // 等价于 std::vector<std::vector<int>>
Matrix<double> double_matrix; // 等价于 std::vector<std::vector<double>>

// 别名模板与模板模板参数结合
template <typename T, template <typename> class Container>
struct MyContainer {
    Container<T> data;
};

template <typename T>
using MyVectorContainer = MyContainer<T, Vec>;

MyVectorContainer<int> container;

模板的性能优化

1. 模板代码膨胀：

   • 原因：为每个模板实例生成单独的代码
   • 影响：增加可执行文件大小和编译时间
   • 解决方案：

          // 使用类型擦除减少代码膨胀
     template <typename T>
     class TypeErasedContainer {
     private:
         struct Concept {
             virtual ~Concept() = default;
             virtual void push_back(const void*) = 0;
             virtual void* get(size_t) = 0;
         };
         
         template <typename U>
         struct Model : Concept {
             std::vector<U> data;
             
             void push_back(const void* value) override {
                 data.push_back(*static_cast<const U*>(value));
             }
             
             void* get(size_t index) override {
                 return &data[index];
             }
         };
         
         std::unique_ptr<Concept> impl;
         
     public:
         template <typename U>
         TypeErasedContainer() : impl(std::make_unique<Model<U>>()) {}
         
         template <typename U>
         void push_back(U value) {
             static_cast<Model<U>*>(impl.get())->push_back(&value);
         }
         
         template <typename U>
         U& get(size_t index) {
             return *static_cast<U*>(static_cast<Model<U>*>(impl.get())->get(index));
         }
     };

2. 编译时间优化：

   • 预编译头文件：将常用模板定义放入预编译头
   • 显式实例化：减少重复实例化
   • 模板拆分：将模板声明和定义分离

      // 显式实例化声明（.h文件）
   extern template class std::vector<int>;
   extern template class std::vector<double>;
   
      // 显式实例化定义（.cpp文件）
   template class std::vector<int>;
   template class std::vector<double>;

3. 运行时性能：

   • 内联展开：模板函数容易被编译器内联
   • 编译期计算：使用constexpr和模板元编程
   • 类型特化：为特定类型提供优化实现

现代C++中的模板特性

1. C++11模板改进：

   • 可变参数模板
   • 别名模板
   • 模板默认参数
   • 外部模板实例化

2. C++14模板改进：

   • 泛型lambda表达式
   • 返回类型推导
   • 变量模板

      // 变量模板（C++14+）
   template <typename T>
   constexpr T pi = T(3.14159265358979323846);
   
   // 使用变量模板
   double area = pi<double> * radius * radius;
   float circumference = 2 * pi<float> * radius;

3. C++17模板改进：

   • 折叠表达式
   • 模板参数推导（类模板参数推导）
   • 内联变量
   • if constexpr

      // 类模板参数推导（C++17+）
   std::pair p(1, 2.5); // 推导为 std::pair<int, double>
   std::vector v = {1, 2, 3}; // 推导为 std::vector<int>
   
      // if constexpr（C++17+）
   template <typename T>
   void process(T t) {
       if constexpr (std::is_integral_v<T>) {
           std::cout << "Integral: " << t << std::endl;
       } else if constexpr (std::is_floating_point_v<T>) {
           std::cout << "Floating point: " << t << std::endl;
       } else {
           std::cout << "Other type" << std::endl;
       }
   }

4. C++20模板改进：

   • 概念（Concepts）
   • 约束模板参数
   • 模块（Modules）
   • 协程（Coroutines）

      // 概念（C++20+）
      template <typename T>
      concept Integral = std::is_integral_v<T>;
      
      template <typename T>
      concept FloatingPoint = std::is_floating_point_v<T>;
      
      // 约束模板参数
   template <Integral T>
   T add(T a, T b) {
       return a + b;
   }
   
   template <FloatingPoint T>
   T add(T a, T b) {
       return a + b;
   }

模板的最佳实践

1. 模板设计原则：

   • 单一职责：每个模板只负责一个功能
   • 可测试性：确保模板可以被有效测试
   • 可扩展性：设计灵活的模板接口
   • 性能考虑：避免不必要的模板实例化

2. 模板编程技巧：

   • 标签分发：使用标签类型选择不同的实现
   • SFINAE：基于替换失败的重载解析
   • CRTP： curiously recurring template pattern
   • 类型 traits：编译期类型信息获取

3. 模板的错误处理：

   • static_assert：编译期断言
   • 概念检查：使用C++20概念进行约束
   • 错误消息优化：提供清晰的错误信息

      // 改进错误消息
   template <typename T>
   void process(T t) {
       static_assert(std::is_integral_v<T>, "T must be an integral type");
       // 处理逻辑
   }

4. 模板的文档和注释：

   • 模板参数说明：详细说明每个模板参数的用途
   • 约束条件：说明模板参数的约束条件
   • 使用示例：提供模板的使用示例

模板元编程的高级技巧

1. 编译期算法：

      // 编译期排序
   template <typename T, T... Ns>
   struct IntegerSequence {
       using type = IntegerSequence;
       static constexpr size_t size = sizeof...(Ns);
   };
   
   // 编译期整数序列生成
   template <size_t N, size_t... Is>
   struct MakeIntegerSequence : MakeIntegerSequence<N-1, N-1, Is...> {};
   
   template <size_t... Is>
   struct MakeIntegerSequence<0, Is...> : IntegerSequence<size_t, Is...> {};
   
   // 编译期最大值查找
   template <typename T, T... Ns>
   struct MaxValue;
   
   template <typename T, T N>
   struct MaxValue<T, N> : std::integral_constant<T, N> {};
   
   template <typename T, T N1, T N2, T... Ns>
   struct MaxValue<T, N1, N2, Ns...> : 
       std::integral_constant<T, N1 > N2 ? MaxValue<T, N1, Ns...>::value : MaxValue<T, N2, Ns...>::value> {};

2. 表达式模板：

      // 表达式模板实现惰性计算
   template <typename T>
   class Vector {
   private:
       std::vector<T> data;
       
   public:
       Vector(size_t size) : data(size) {}
       
       T& operator[](size_t index) { return data[index]; }
       const T& operator[](size_t index) const { return data[index]; }
       size_t size() const { return data.size(); }
   };
   
   // 表达式模板基类
   template <typename T, typename Expr>
   class VectorExpr {
   public:
       T operator[](size_t index) const {
           return static_cast<const Expr&>(*this)[index];
       }
       
       size_t size() const {
           return static_cast<const Expr&>(*this).size();
       }
   };
   
   // 向量加法表达式
   template <typename T, typename Lhs, typename Rhs>
   class VectorAdd : public VectorExpr<T, VectorAdd<T, Lhs, Rhs>> {
   private:
       const Lhs& lhs;
       const Rhs& rhs;
       
   public:
       VectorAdd(const Lhs& l, const Rhs& r) : lhs(l), rhs(r) {}
       
       T operator[](size_t index) const {
           return lhs[index] + rhs[index];
       }
       
       size_t size() const {
           return lhs.size();
       }
   };
   
   // 运算符重载
   template <typename T, typename Lhs, typename Rhs>
   VectorAdd<T, Lhs, Rhs> operator+(const VectorExpr<T, Lhs>& lhs, const VectorExpr<T, Rhs>& rhs) {
       return VectorAdd<T, Lhs, Rhs>(static_cast<const Lhs&>(lhs), static_cast<const Rhs&>(rhs));
   }
   
   // 从表达式构造向量
   template <typename T, typename Expr>
   Vector<T> operator+(const Vector<T>& vec, const VectorExpr<T, Expr>& expr) {
       Vector<T> result(vec.size());
       for (size_t i = 0; i < vec.size(); ++i) {
           result[i] = vec[i] + expr[i];
       }
       return result;
   }

3. 策略模式与模板：

      // 使用模板实现策略模式
   template <typename SortStrategy, typename Container>
   void sort(Container& container) {
       SortStrategy::sort(container);
   }
   
   // 排序策略
   truct BubbleSort {
       template <typename Container>
       static void sort(Container& container) {
           // 冒泡排序实现
           for (size_t i = 0; i < container.size() - 1; ++i) {
               for (size_t j = 0; j < container.size() - i - 1; ++j) {
                   if (container[j] > container[j + 1]) {
                       std::swap(container[j], container[j + 1]);
                   }
               }
           }
       }
   };
   
   truct QuickSort {
       template <typename Container>
       static void sort(Container& container) {
           // 快速排序实现
           if (container.size() <= 1) return;
           
           auto pivot = container[container.size() / 2];
           Container left, middle, right;
           
           for (auto& item : container) {
               if (item < pivot) left.push_back(item);
               else if (item == pivot) middle.push_back(item);
               else right.push_back(item);
           }
           
           sort<QuickSort>(left);
           sort<QuickSort>(right);
           
           container.clear();
           container.insert(container.end(), left.begin(), left.end());
           container.insert(container.end(), middle.begin(), middle.end());
           container.insert(container.end(), right.begin(), right.end());
       }
   };
   
   // 使用策略
   std::vector<int> vec = {3, 1, 4, 1, 5, 9, 2, 6};
   sort<BubbleSort>(vec); // 使用冒泡排序
   sort<QuickSort>(vec); // 使用快速排序

模板在标准库中的应用

1. STL容器：

   • std::vector<T>：动态数组
   • std::list<T>：双向链表
   • std::map<K, V>：关联容器

2. 算法库：

   • std::sort：排序算法
   • std::find：查找算法
   • std::transform：变换算法

3. 智能指针：

   • std::unique_ptr<T>：独占所有权指针
   • std::shared_ptr<T>：共享所有权指针
   • std::weak_ptr<T>：弱引用指针

4. 函数对象：

   • std::function<T>：通用函数包装器
   • std::bind：函数绑定
   • std::mem_fn：成员函数适配器

模板编程的未来发展

1. C++23模板改进：

   • 显式对象参数
   • 多维下标运算符
   • 静态运算符

2. C++26及以后：

   • 反射（Reflection）
   • 元类（Metaclasses）
   • 编译期字符串操作

3. 模板编程的趋势：

   • 更强大的编译期计算能力
   • 更简洁的语法
   • 更好的错误消息
   • 与现代C++特性的深度集成

模板是C++中最强大的特性之一，它不仅支持泛型编程，还为编译期计算和元编程提供了基础。随着C++标准的不断发展，模板的能力也在不断增强，为C++程序员提供了越来越多的工具和技巧。

掌握模板编程需要时间和实践，但它将为你打开C++编程的新境界，使你能够编写更灵活、更高效、更可维护的代码。
std::cout << “Base::value = “ << value << std::endl; // 可以访问，因为是保护继承
}
};

## 可变参数模板与模板特化

### 可变参数模板的实现

```cpp
// 递归终止条件
template <typename T>
void print(T value) {
    std::cout << value << std::endl;
}

// 可变参数模板
template <typename T, typename... Args>
void print(T first, Args... rest) {
    std::cout << first << " ";
    print(rest...); // 递归调用
}

// 使用可变参数模板
print(1, 2.5, "Hello", true);

折叠表达式（C++17）

// 使用折叠表达式简化可变参数处理
template <typename... Args>
void print(Args&&... args) {
    (std::cout << ... << args) << std::endl;
}

// 带分隔符的折叠表达式
template <typename... Args>
void print_with_separator(Args&&... args) {
    const char* sep = "";
    ((std::cout << sep << args), sep = ", ")...;
    std::cout << std::endl;
}

模板特化

类模板特化

// 主模板
template <typename T>
class Container {
public:
    void add(T value) {
        std::cout << "Adding value: " << value << std::endl;
    }
};

// 特化版本
template <>
class Container<std::string> {
public:
    void add(std::string value) {
        std::cout << "Adding string: '" << value << "'" << std::endl;
    }
};

// 偏特化版本
template <typename T>
class Container<T*> {
public:
    void add(T* value) {
        if (value) {
            std::cout << "Adding pointer: " << *value << std::endl;
        } else {
            std::cout << "Adding null pointer" << std::endl;
        }
    }
};

函数模板特化

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

// 特化版本
template <>
const char* max<const char*>(const char* a, const char* b) {
    return std::strcmp(a, b) > 0 ? a : b;
}

概念（Concepts）与模板约束

自定义概念

#include <concepts>

// 自定义概念
template <typename T>
concept Numeric = std::integral<T> || std::floating_point<T>;

template <typename T>
concept Hashable = requires(T a) {
    { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;
};

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

// 使用概念约束模板参数
template <Numeric T>
T sum(T a, T b) {
    return a + b;
}

template <Hashable T>
void hash_value(T value) {
    std::size_t hash = std::hash<T>{}(value);
    std::cout << "Hash: " << hash << std::endl;
}

template <Sortable T>
void sort_values(std::vector<T>& values) {
    std::sort(values.begin(), values.end());
}

概念的组合

// 组合多个概念
template <typename T>
concept NumericAndSortable = Numeric<T> && Sortable<T>;

template <typename T>
concept StringLike = 
    std::same_as<T, std::string> || 
    std::same_as<T, std::string_view> ||
    std::same_as<T, const char*>;

// 使用组合概念
template <NumericAndSortable T>
T find_min(const std::vector<T>& values) {
    return *std::min_element(values.begin(), values.end());
}

template <StringLike T>
std::string to_string(T value) {
    if constexpr (std::same_as<T, const char*>) {
        return std::string(value);
    } else {
        return std::string(value);
    }
}

C++20模板增强

模板Lambda

#include <iostream>

int main() {
    // 模板lambda
    auto add = []<typename T>(T a, T b) {
        return a + b;
    };
    
    // 使用不同类型
    std::cout << "Add integers: " << add(1, 2) << std::endl;
    std::cout << "Add doubles: " << add(1.5, 2.5) << std::endl;
    std::cout << "Add strings: " << add(std::string("Hello"), std::string(" World")) << std::endl;
    
    // 带约束的模板lambda
    auto multiply = []<typename T>(T a, T b) requires std::is_arithmetic_v<T> {
        return a * b;
    };
    
    std::cout << "Multiply integers: " << multiply(3, 4) << std::endl;
    std::cout << "Multiply doubles: " << multiply(2.5, 4.0) << std::endl;
    
    // 可变参数模板lambda
    auto print = []<typename... Args>(Args&&... args) {
        (std::cout << ... << args) << std::endl;
    };
    
    print("The answer is ", 42, ", and pi is ", 3.14159);
    
    return 0;
}

带requires表达式的模板

#include <concepts>
#include <iostream>

// 使用requires表达式约束模板参数
 template <typename T>
 requires std::integral<T> || std::floating_point<T>
T absolute(T value) {
    return value < 0 ? -value : value;
}

// 结合概念使用
 template <std::integral T>
T square(T value) {
    return value * value;
}

// 带多个约束的模板
 template <typename T>
 requires std::copyable<T> && requires(T a, T b) {
     { a + b } -> std::same_as<T>;
     { a * b } -> std::same_as<T>;
 }
T sum_and_product(T a, T b) {
    return a + b * a;
}

int main() {
    std::cout << "Absolute value of -5: " << absolute(-5) << std::endl;
    std::cout << "Absolute value of -3.14: " << absolute(-3.14) << std::endl;
    
    std::cout << "Square of 5: " << square(5) << std::endl;
    
    std::cout << "Sum and product of 3 and 4: " << sum_and_product(3, 4) << std::endl;
    
    return 0;
}

C++20模板增强的优点

1. 更简洁的语法：模板lambda简化了泛型lambda的写法
2. 更强的表达能力：requires表达式提供了更灵活的模板约束方式
3. 更好的错误信息：当模板参数不满足约束时，提供更清晰的错误信息
4. 更高的代码可读性：使用概念和requires表达式使模板代码更易于理解
5. 更好的编译性能：编译器可以更早地检查模板参数的有效性

模板元编程高级技巧

编译期类型列表

// 类型列表
template <typename... Types>
struct TypeList {};

// 类型列表操作
template <typename List>
struct Length;

template <typename... Types>
struct Length<TypeList<Types...>> {
    static constexpr size_t value = sizeof...(Types);
};

template <typename List, size_t Index>
struct TypeAt;

template <typename T, typename... Types>
struct TypeAt<TypeList<T, Types...>, 0> {
    using type = T;
};

template <typename T, typename... Types, size_t Index>
struct TypeAt<TypeList<T, Types...>, Index> {
    using type = typename TypeAt<TypeList<Types...>, Index - 1>::type;
};

// 使用类型列表
using MyTypes = TypeList<int, double, std::string>;
static constexpr size_t size = Length<MyTypes>::value; // 3
using SecondType = TypeAt<MyTypes, 1>::type; // double

编译期算法

// 编译期查找
template <typename List, typename T>
struct Contains;

template <typename T>
struct Contains<TypeList<>, T> {
    static constexpr bool value = false;
};

template <typename T, typename... Types>
struct Contains<TypeList<T, Types...>, T> {
    static constexpr bool value = true;
};

template <typename U, typename T, typename... Types>
struct Contains<TypeList<U, Types...>, T> {
    static constexpr bool value = Contains<TypeList<Types...>, T>::value;
};

// 编译期过滤
template <typename List, template <typename> typename Predicate>
struct Filter;

template <template <typename> typename Predicate>
struct Filter<TypeList<>, Predicate> {
    using type = TypeList<>;
};

template <typename T, typename... Types, template <typename> typename Predicate>
struct Filter<TypeList<T, Types...>, Predicate> {
    using Rest = typename Filter<TypeList<Types...>, Predicate>::type;
    using type = std::conditional_t<
        Predicate<T>::value,
        TypeList<T, Rest>,
        Rest
    >;
};

// 使用编译期算法
using FilteredTypes = Filter<MyTypes, std::is_arithmetic>::type; // TypeList<int, double>
static constexpr bool has_string = Contains<MyTypes, std::string>::value; // true

策略模式与模板

// 策略接口
template <typename T>
class SortStrategy {
public:
    virtual void sort(std::vector<T>& data) = 0;
    virtual ~SortStrategy() = default;
};

// 具体策略
template <typename T>
class QuickSort : public SortStrategy<T> {
public:
    void sort(std::vector<T>& data) override {
        std::sort(data.begin(), data.end());
        std::cout << "Sorted with QuickSort" << std::endl;
    }
};

template <typename T>
class BubbleSort : public SortStrategy<T> {
public:
    void sort(std::vector<T>& data) override {
        // 简化的冒泡排序
        for (size_t i = 0; i < data.size(); i++) {
            for (size_t j = 0; j < data.size() - i - 1; j++) {
                if (data[j] > data[j + 1]) {
                    std::swap(data[j], data[j + 1]);
                }
            }
        }
        std::cout << "Sorted with BubbleSort" << std::endl;
    }
};

// 策略选择器（模板版本）
template <typename T, template <typename> typename SortAlgorithm>
class Sorter {
public:
    void sort(std::vector<T>& data) {
        SortAlgorithm<T> algorithm;
        algorithm.sort(data);
    }
};

// 使用策略模式
std::vector<int> data = {5, 2, 8, 1, 9};
Sorter<int, QuickSort> quickSorter;
quickSorter.sort(data);

Sorter<int, BubbleSort> bubbleSorter;
bubbleSorter.sort(data);

模板编程的总结与展望

模板是C++中最强大的特性之一，它不仅支持泛型编程，还为编译期计算和元编程提供了基础。通过本章的学习，我们掌握了以下核心内容：

核心概念

1. 模板实例化机制：编译器为每个唯一的模板实例生成专门的代码，实现了真正的类型安全的泛型编程
2. 模板元编程：利用模板在编译期进行计算和类型操作，实现了编译期反射、算法和逻辑
3. SFINAE技术：基于替换失败的重载解析，实现了编译期类型特性检测
4. 可变参数模板：支持任意数量的模板参数，为元编程和泛型算法提供了强大工具
5. 模板模板参数：允许将模板作为另一个模板的参数，实现了更高层次的抽象

现代C++中的模板特性

1. C++11：引入了可变参数模板、别名模板、模板默认参数等特性
2. C++14：增加了泛型lambda表达式、返回类型推导、变量模板等特性
3. C++17：引入了折叠表达式、类模板参数推导、if constexpr等特性
4. C++20：添加了概念（Concepts）、约束模板参数、模块等特性

模板编程的最佳实践

1. 性能优化：

   • 避免不必要的模板实例化
   • 使用类型擦除减少代码膨胀
   • 利用编译期计算提高运行时性能

2. 代码组织：

   • 将模板声明和定义分离
   • 使用显式实例化减少编译时间
   • 合理使用模板特化优化特定类型的性能

3. 错误处理：

   • 使用static_assert进行编译期断言
   • 利用概念（C++20+）提供清晰的错误消息
   • 设计模板接口时考虑错误消息的可读性

模板编程的未来发展

1. C++23：引入了显式对象参数、多维下标运算符、静态运算符等特性

2. C++26及以后：

   • 反射（Reflection）：提供编译期类型信息获取能力
   • 元类（Metaclasses）：允许在编译期修改类的结构
   • 编译期字符串操作：增强编译期计算能力

3. 模板编程的趋势：

   • 更强大的编译期计算能力
   • 更简洁的语法和更好的错误消息
   • 与现代C++特性的深度集成
   • 更广泛的应用场景（如嵌入式系统、游戏开发、金融计算等）

学习建议

掌握模板编程需要时间和实践，以下是一些学习建议：

1. 从基础开始：先掌握函数模板和类模板的基本用法
2. 循序渐进：逐步学习可变参数模板、模板元编程等高级特性
3. 实践中学习：通过编写实际项目代码来巩固模板编程技能
4. 参考优秀代码：学习标准库和知名开源项目中的模板使用技巧
5. 关注标准发展：了解C++标准中模板特性的最新进展

模板编程是C++程序员的重要工具，它不仅可以提高代码的复用性和可维护性，还可以为程序性能带来显著提升。随着C++标准的不断发展，模板的能力也在不断增强，为C++程序员提供了越来越多的工具和技巧。

通过合理使用模板，你可以编写更加灵活、更加高效、更加可维护的C++代码，充分发挥C++的性能优势和表达能力。