C++ 模板方法模式

2025年3月21日 | 阅读 6 分钟

模板方法模式是面向对象编程中一个著名的行为设计模式，它定义了一个算法的整体结构或骨架，其中算法的某些步骤可以由派生类定制，而无需改变整体算法的步骤序列。该模式的核心思想是允许算法的特定细节由子类重新定义，同时在基类中保持算法不变的方面。

该模式在您有算法的几种变体，并且希望封装算法的共同部分以避免重复的情况下特别有用。算法中可能因不同用例而异的步骤被标记为“钩子”或“抽象操作”，子类可以重写这些步骤以提供自己的特定行为。同时，算法的总体流程和结构保留在基类中，这允许灵活性而不会损害可重用性。

模板方法模式的关键概念

C++ 中的模板方法模式的几个关键概念如下：

基类中的算法骨架： 模板方法在基类中定义算法的高层结构，规定了所涉及的步骤。但是，它允许某些步骤由子类重写。它促进了代码重用，因为整体过程只实现一次，只有可变部分需要由子类定制。
派生类中的定制： 算法中可能在不同上下文中改变的特定步骤被抽象化（纯虚函数），并提供默认行为，派生类可以重写这些行为。这些方法允许在派生类中进行定制和扩展，而不会影响基类的模板方法。
钩子： 钩子是模式的可选部分，其中方法具有默认实现，但可以由子类重写以扩展或修改算法的行为。它允许派生类对算法拥有一定的控制权，而无需强制重写每个步骤。

程序

让我们举一个例子来说明 C++ 中的模板方法模式。

 
#include <iostream>
#include <string>
#include <vector>
#include <stdexcept>
#include <memory>
#include <sstream>
// Abstract Base Class defining the Template Method pattern
class DataProcessor {
public:
    // Template Method defining the skeleton of the data processing algorithm
    void processData() {
        try {
            initialize();
            loadData();
            parseData();
            validateData();
            processParsedData();
        } catch (const std::exception& e) {
            handleProcessingError(e.what());
        } finally();
    }
protected:
    // Hook: Initialization step (can be overridden by derived classes)
    virtual void initialize() {
        std::cout << "Initializing data processing...\n";
    }
    // Step 1: Load data (abstract, must be implemented by derived classes)
    virtual void loadData() = 0;
    // Step 2: Parse data (abstract, must be implemented by derived classes)
    virtual void parseData() = 0;
    // Step 3: Validate parsed data (abstract, must be implemented by derived classes)
    virtual void validateData() = 0;
    // Step 4: Process parsed and validated data (default implementation)
    virtual void processParsedData() {
        std::cout << "Processing parsed data...\n";
        for (const std::string& record : parsedData) {
            std::cout << "Processing record: " << record << "\n";
        }
    }
    // Hook: Final cleanup step (can be overridden by derived classes)
    virtual void finally() {
        std::cout << "Final cleanup after data processing.\n";
    }
    // Optional Hook for error handling (can be overridden)
    virtual void handleProcessingError(const std::string& error) {
        std::cerr << "Error encountered during data processing: " << error << "\n";
   }
    // Internal storage for parsed data
    std::vector<std::string> parsedData;
};
// Derived class for processing data from files
class FileDataProcessor : public DataProcessor {
protected:
    void initialize() override {
        std::cout << "Opening file for data processing...\n";
    }
    void loadData() override {
        std::cout << "Loading data from file...\n";
        rawData = "File Data: ID=101, Name=John Doe, Age=45";
    }
    void parseData() override {
        std::cout << "Parsing file data...\n";
        std::istringstream ss(rawData);
        std::string token;
        while (std::getline(ss, token, ',')) {
            parsedData.push_back(token);
        }
    }
    void validateData() override {
        std::cout << "Validating file data...\n";
        if (parsedData.empty()) {
            throw std::runtime_error("No data parsed from file.");
        }
    }
    void finally() override {
        std::cout << "Closing file and releasing resources...\n";
    }
private:
    std::string rawData;
};
// Derived class for processing data from a database
class DatabaseDataProcessor : public DataProcessor {
protected:
    void initialize() override {
        std::cout << "Connecting to database...\n";
    }
    void loadData() override {
        std::cout << "Loading data from database...\n";
        rawData = "Database Data: ID=202, Name=Jane Smith, Salary=75000";
    }
    void parseData() override {
        std::cout << "Parsing database data...\n";
        std::istringstream ss(rawData);
        std::string token;
        while (std::getline(ss, token, ',')) {
            parsedData.push_back(token);
        }
    }
    void validateData() override {
        std::cout << "Validating database data...\n";
        if (parsedData.size() < 3) {
            throw std::runtime_error("Incomplete data from database.");
        }
    }
    void finally() override {
        std::cout << "Disconnecting from database...\n";
    }
private:
    std::string rawData;
};
// Derived class for processing data from an API
class APIDataProcessor : public DataProcessor {
protected:
    void loadData() override {
        std::cout << "Fetching data from API...\n";
        rawData = "{ \"ID\": 303, \"Name\": \"Alice Johnson\", \"Country\": \"USA\" }";
    }
    void parseData() override {
        std::cout << "Parsing API data...\n";
        std::istringstream ss(rawData);
        std::string token;
        while (std::getline(ss, token, ',')) {
            parsedData.push_back(token);
        }
    }
    void validateData() override {
        std::cout << "Validating API data...\n";
        if (parsedData.size() < 3) {
            throw std::runtime_error("Invalid API response.");
        }
    }
    void finally() override {
        std::cout << "Releasing API resources...\n";
    }
private:
    std::string rawData;
};
// Derived class for processing XML data
class XMLDataProcessor : public DataProcessor {
protected:
    void initialize() override {
        std::cout << "Preparing to load XML data...\n";
    }
    void loadData() override {
        std::cout << "Loading XML data...\n";
        rawData = "<Person><ID>404</ID><Name>Bob Marley</Name><Age>36</Age></Person>";
    }
    void parseData() override {
        std::cout << "Parsing XML data...\n";
        // Simulating simple XML parsing by extracting strings
        parsedData = { "ID=404", "Name=Bob Marley", "Age=36" };
    }
    void validateData() override {
        std::cout << "Validating XML data...\n";
        if (parsedData.size() != 3) {
            throw std::runtime_error("XML data is corrupted.");
        }
    }
    void handleProcessingError(const std::string& error) override {
        std::cerr << "XML Error: " << error << "\n";
    }
    void finally() override {
        std::cout << "XML data processed successfully. Cleaning up resources...\n";
    }
private:
    std::string rawData;
};
// Client code to use the Template Method pattern
int main() {
    std::vector<std::unique_ptr<DataProcessor>> processors;
    // Create instances of different processors
    processors.push_back(std::make_unique<FileDataProcessor>());
    processors.push_back(std::make_unique<DatabaseDataProcessor>());
    processors.push_back(std::make_unique<APIDataProcessor>());
    processors.push_back(std::make_unique<XMLDataProcessor>());
    // Process data for each source
    for (auto& processor : processors) {
       std::cout << "\nStarting Data Processing \n";
        processor->processData();
    }
    return 0;
}   

输出

 
Starting Data Processing 
Opening file for data processing...
Loading data from file...
Parsing file data...
Validating file data...
Processing parsed data...
Processing record: File Data: ID=101
Processing record:  Name=John Doe
Processing record:  Age=45
Closing file and releasing resources...

Starting Data Processing 
Connecting to database...
Loading data from database...
Parsing database data...
Validating database data...
Processing parsed data...
Processing record: Database Data: ID=202
Processing record:  Name=Jane Smith
Processing record:  Salary=75000
Disconnecting from database...

Starting Data Processing 
Initializing data processing...
Fetching data from API...
Parsing API data...
Validating API data...
Processing parsed data...
Processing record: { "ID": 303
Processing record:  "Name": "Alice Johnson"
Processing record:  "Country": "USA" }
Releasing API resources...

Starting Data Processing 
Preparing to load XML data...
Loading XML data...
Parsing XML data...
Validating XML data...
Processing parsed data...
Processing record: ID=404
Processing record: Name=Bob Marley
Processing record: Age=36
XML data processed successfully. Cleaning up resources...

说明

在此示例中，提供的 C++ 代码演示了模板方法模式，该模式在基类（'DataProcessor'）中定义了一个通用算法结构，同时允许派生类实现特定行为。'processData()' 方法概述了步骤：初始化、数据加载、解析、验证、处理和清理。抽象方法（'loadData()'、'parseData()'、'validateData()'）必须由派生类（如 'FileDataProcessor'、'DatabaseDataProcessor'、'APIDataProcessor' 和 'XMLDataProcessor'）实现。

每个派生类根据数据源（文件、数据库、API、XML）定制数据加载、解析和验证的方式。'initialize()' 和 'finally()' 钩子管理设置和清理操作，而 'handleProcessingError()' 函数处理错误，可以在子类中重写以进行特定的错误报告。

'main()' 函数通过调用 'processData()' 函数处理来自不同源的数据，这突出了模板方法模式在处理各种数据类型时具有统一算法结构的灵活性。

复杂度分析

时间复杂度

加载数据（loadData()）： 复杂性取决于源（例如，文件、数据库和 API）。如果从文件或 API 加载数据涉及读取固定量的数据，则通常为 O(n)，其中 n 是数据的大小。
解析数据（parseData()）： 解析大小为 n 的字符串通常需要 O(n)。
验证数据（validateData()）： 验证可能会遍历解析的数据，使其为 O(n)。

每个数据源的总时间复杂度为 O(n)，其中 n 是正在处理的数据量。

空间复杂度

空间主要由存储原始数据和解析数据决定。对于 n 个解析数据元素，空间复杂度为 O(n)。

总的来说，空间复杂度为 O(n)，主要由存储输入数据和解析结果决定。

下一主题关于 C++ 的有趣事实

C++ 模板方法模式

模板方法模式的关键概念

程序

说明

复杂度分析

时间复杂度

空间复杂度

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

C++ 教程

C++ 控制语句

C++ 函数

C++ 数组

C++ 类和对象

C++ 构造函数

C++ 继承

C++ 多态

C++ 抽象

C++ 命名空间

C++ 模板

C++ 字符串

C++ 指针

信号处理

C++ 异常

C++ 文件与流

C++ STL 教程

面试题

选择题

C++ 程序

C++ STL Stack

C++ STL Bitset

C++ STL Deque

C++ STL List

C++ STL Map

C++ STL Math

C++ STL priority_queue

C++ STL Queue

C++ STL Multiset

C++ STL Multimap

C++ STL Set

C++ STD Strings

C++ STL Vector

C++ 操纵符

C++ STL Algorithms

C++ Algorithm

C++ Iterators

C++ 杂项

C++ 模板方法模式

模板方法模式的关键概念

程序

说明

复杂度分析

时间复杂度

空间复杂度

相关帖子

C++ 中的邪恶数字

C++ 中关于斐波那契数列的有趣事实

C++ 中打印内部递减模式

C++ 中的突发排序算法

C++ STL 中的 UTF-8 到宽字符转换

C++ 中的 std::is_destructible

C++ 中通过加减从 1 开始的数字使 X = Y 的最小移动次数

C++ 双向线性搜索算法

C++ 预处理器指令与函数模板的区别

C++ 中的卡迈克尔数

订阅 Tpoint Tech

联系信息

关注我们

教程