C++模板类设计模式：策略与工厂模式的模板实现精讲

# 1. C++模板类设计模式概览

在本章中，我们将深入探讨C++模板类设计模式的基本概念和原则。C++模板类是一种强大的工具，它允许我们编写与数据类型无关的代码，实现代码的复用和泛型编程。我们将从模板类的定义开始，逐步揭示其灵活性和强大功能背后的原理。

## 1.1 模板类的概念

C++模板类提供了一种方式来定义一个类或者函数，它的实现不依赖于特定的数据类型。这种机制极大地增强了代码的通用性和可重用性。通过使用模板，开发者可以创建一个单一的类定义，而无需重复编写相同的代码来处理不同的数据类型。

## 1.2 模板类的优势

使用模板类带来的一个显著优势是代码的类型安全。编译器可以在编译时期就检查类型相关的问题，从而减少运行时错误。此外，模板类能够优化性能，因为它在编译时确定类型，允许编译器进行更高级别的优化。

## 1.3 模板类的基本语法

C++模板类的声明通常使用关键字 `template` 后跟一个或多个模板参数。例如，一个简单的模板类可能这样定义：

template <typename T>
class Example {
public:
    Example(T value) : data(value) {}
    void print() {
        std::cout << data << std::endl;
    }
private:
    T data;
};

在此基础上，我们可以创建不同类型的 `Example` 对象，而无需为每种类型编写新的类定义。这就是C++模板类设计模式的魅力所在。接下来，我们将探讨具体的模板模式实现。

# 2. 策略模式的模板实现

## 2.1 策略模式的基本原理

### 2.1.1 策略模式的定义与结构

策略模式是一种行为设计模式，它定义了一系列算法，并将每一个算法封装起来，使它们可以互相替换。策略模式让算法可以独立于使用它的客户端变化。

在策略模式中，通常涉及以下几个角色：

- **上下文(Context)：** 对象，持有一个策略的引用，上下文会将客户的请求委托给策略。
- **策略(Strategy)：** 接口定义所有支持的算法的公共接口。上下文使用这个接口来调用定义在具体策略类中的算法。
- **具体策略(Concrete Strategies)：** 实现了策略接口的具体算法类。

策略模式的结构可以用下图表示：

### 2.1.2 策略模式的适用场景和优缺点

#### 适用场景

- 如果您想使用对象代表算法，而算法在运行时会有所不同。
- 如果您有多个类仅在行为上略有不同，并且您将创建一个新的类来封装每一种行为，那么策略模式将非常有用。
- 如果一个类定义了很多行为，并且这些行为在其内部以一系列条件语句的形式出现，策略模式可以将这些条件分支的代码块移出类。

#### 优点

- 上下文与策略类可以独立变化，相互独立。
- 提高了算法的扩展性，符合开闭原则。

#### 缺点

- 客户端必须了解不同的策略，以便知道要使用哪种策略。
- 策略模式会增加类的数量。

## 2.2 策略模式的模板实现

### 2.2.1 模板类的定义与使用

在C++中，模板类可以用来实现策略模式，其中模板参数可以作为算法的抽象。这意味着在编译时决定具体使用的算法，而不是在运行时。这种策略模式的模板实现可以避免虚函数的开销。

定义一个策略模板接口：

template<typename T>
class Strategy {
public:
    virtual ~Strategy() {}
    virtual T execute(const T& data) = 0;
};

实现具体策略：

template<typename T>
class ConcreteStrategyA : public Strategy<T> {
public:
    T execute(const T& data) override {
        // 实现具体的策略算法A
        return T(); // 返回处理后的数据
    }
};

template<typename T>
class ConcreteStrategyB : public Strategy<T> {
public:
    T execute(const T& data) override {
        // 实现具体的策略算法B
        return T(); // 返回处理后的数据
    }
};

使用策略：

template<typename T>
class Context {
private:
    Strategy<T>* strategy_;
public:
    Context(Strategy<T>* strategy) : strategy_(strategy) {}
    T executeStrategy(const T& data) {
        return strategy_->execute(data);
    }
    ~Context() {
        delete strategy_;
    }
};

### 2.2.2 具体策略的模板实例化

在实际使用时，创建具体策略的实例，并在上下文对象中使用。

int main() {
    ConcreteStrategyA<int> strategyA;
    ConcreteStrategyB<int> strategyB;
    Context<int> contextA(&strategyA);
    Context<int> contextB(&strategyB);
    int data = 10;
    std::cout << "Context A using strategy A: " << contextA.executeStrategy(data) << std::endl;
    std::cout << "Context B using strategy B: " << contextB.executeStrategy(data) << std::endl;
    return 0;
}

## 2.3 策略模式实践应用

### 2.3.1 实例：排序算法的选择与应用

考虑一个场景，我们需要一个排序算法，但是排序算法的类型取决于用户的选择。我们可以使用策略模式来选择不同的排序策略。

定义排序策略接口：

template<typename T>
class SortStrategy {
public:
    virtual ~SortStrategy() {}
    virtual void sort(std::vector<T>& elements) = 0;
};

实现不同的排序算法：

template<typename T>
class QuickSort : public SortStrategy<T> {
public:
    void sort(std::vector<T>& elements) override {
        // 实现快速排序逻辑
    }
};

template<typename T>
class MergeSort : public SortStrategy<T> {
public:
    void sort(std::vector<T>& elements) override {
        // 实现归并排序逻辑
    }
};

在上下文中使用策略：

template<typename T>
class SortContext {
private:
    SortStrategy<T>* strategy_;
public:
    SortContext(SortStrategy<T>* strategy) : strategy_(strategy) {}
    void sort(std::vector<T>& elements) {
        strategy_->sort(elements);
    }
    ~SortContext() {
        delete strategy_;
    }
};

使用时可以根据需要选择不同的排序策略：

std::vector<int> elements = {5, 3, 8, 4, 2};
SortContext<int> sortContext(new QuickSort<int>());
sortContext.sort(elements);

### 2.3.2 实例：日志记录器的策略实现

另一个例子是日志记录器，它可以选择不同的记录策略。

定义日志记录策略接口：

class LogStrategy {
public:
    virtual ~LogStrategy() {}
    virtual void log(const std::string& message) = 0;
};

实现不同的日志记录方法：

class FileLogStrategy : public LogStrategy {
public:
    void log(const std::string& message) override {
        // 实现将消息写入文件
    }
};

class ConsoleLogStrategy : public LogStrategy {
public:
    void log(const std::string& message) o