C++模板方法模式与代码复用实现（复用.模板.模式.代码.方法...）

模板方法模式通过抽象基类定义算法骨架，子类实现具体步骤。其核心构成包括：抽象基类、模板方法（固定流程）、基本操作（纯虚函数，子类实现）、钩子方法（可选覆盖）和具体子类。该模式提升代码复用性，因公共流程集中于基类；增强可维护性，遵循“好莱坞原则”，子类无需调用基类，仅扩展特定行为，结构清晰，扩展灵活。

c++模板方法模式与代码复用实现

C++的模板方法模式，在我看来，就是一种巧妙的算法骨架设计。它允许你在一个基类中定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。核心目的是在不改变算法结构的前提下，让子类可以重新定义算法的某些特定步骤，从而实现代码的有效复用。这不仅仅是一种设计模式，更是一种思维方式，引导我们如何优雅地处理变与不变。

要实现模板方法模式，我们通常会创建一个抽象基类，其中包含一个非虚的“模板方法”——这就是算法的骨架。这个模板方法会调用一系列虚函数（或纯虚函数），这些虚函数就是算法中可以被子类定制的“基本操作”。子类通过重写这些虚函数来提供自己的特定实现。

举个例子，假设我们要构建不同型号的汽车。虽然每种车的具体部件和组装方式可能不同，但整体的“造车流程”是相似的：设计、制造车身、安装引擎、喷漆、测试。

#include <iostream>
#include <string>
#include <vector>

// 抽象基类：定义造车流程的骨架
class CarBuilder {
public:
    // 模板方法：定义了造车的固定流程，不可被子类重写
    void buildCar() {
        designCar();
        manufactureBody();
        installEngine();
        paintCar();
        testCar();
        // 这是一个钩子方法，子类可以选择性实现
        if (addOptionalFeatures()) {
            std::cout << "Adding optional features specific to " << getCarModel() << std::endl;
        }
        std::cout << getCarModel() << " car built successfully!\n" << std::endl;
    }

    // 纯虚函数：必须由子类实现的基本操作
    virtual void designCar() = 0;
    virtual void manufactureBody() = 0;
    virtual void installEngine() = 0;
    virtual void paintCar() = 0;
    virtual void testCar() = 0;

    // 钩子方法：有默认实现，子类可以选择性覆盖
    virtual bool addOptionalFeatures() {
        return false; // 默认不添加额外功能
    }

    // 辅助方法，用于获取模型名称
    virtual std::string getCarModel() const = 0;

    virtual ~CarBuilder() = default;
};

// 具体子类：实现轿车建造流程
class SedanCarBuilder : public CarBuilder {
public:
    void designCar() override {
        std::cout << "Designing a sleek Sedan model." << std::endl;
    }
    void manufactureBody() override {
        std::cout << "Manufacturing Sedan body with lightweight materials." << std::endl;
    }
    void installEngine() override {
        std::cout << "Installing a 1.5L turbocharged engine for Sedan." << std::endl;
    }
    void paintCar() override {
        std::cout << "Painting Sedan in metallic silver." << std::endl;
    }
    void testCar() override {
        std::cout << "Performing urban driving tests for Sedan." << std::endl;
    }
    bool addOptionalFeatures() override {
        std::cout << "Adding heated seats and panoramic sunroof for Sedan." << std::endl;
        return true; // 轿车默认添加额外功能
    }
    std::string getCarModel() const override {
        return "Sedan";
    }
};

// 具体子类：实现SUV建造流程
class SUVCarBuilder : public CarBuilder {
public:
    void designCar() override {
        std::cout << "Designing a robust SUV model with high ground clearance." << std::endl;
    }
    void manufactureBody() override {
        std::cout << "Manufacturing SUV body with reinforced steel frame." << std::endl;
    }
    void installEngine() override {
        std::cout << "Installing a 2.0L powerful engine for SUV." << std::endl;
    }
    void paintCar() override {
        std::cout << "Painting SUV in matte black." << std::endl;
    }
    void testCar() override {
        std::cout << "Performing off-road and safety tests for SUV." << std::endl;
    }
    std::string getCarModel() const override {
        return "SUV";
    }
    // SUV不添加可选功能，使用默认实现（即不覆盖addOptionalFeatures）
};

/*
// 示例用法
int main() {
    std::cout << "--- Building a Sedan ---" << std::endl;
    CarBuilder* sedanBuilder = new SedanCarBuilder();
    sedanBuilder->buildCar();

    std::cout << "--- Building an SUV ---" << std::endl;
    CarBuilder* suvBuilder = new SUVCarBuilder();
    suvBuilder->buildCar();

    delete sedanBuilder;
    delete suvBuilder;
    return 0;
}
*/

在这个例子中，

CarBuilder

定义了

buildCar

这个模板方法，它固定了造车的步骤。而

designCar

manufactureBody

等是纯虚函数，子类

SedanCarBuilder

和

SUVCarBuilder

各自提供了这些步骤的具体实现。

addOptionalFeatures

是一个钩子方法，子类可以根据需要选择是否覆盖，比如

SedanCarBuilder

就覆盖了它来添加额外功能。 C++模板方法模式的核心构成要素有哪些？

这个模式的核心，在我看来，可以拆解为几个关键角色，它们协同工作，共同构建出那个“不变的骨架，可变的细节”的哲学。

是那个抽象基类 (Abstract Base Class)。它是整个模式的灵魂，定义了算法的整体结构，也就是我们常说的“骨架”。这个基类会包含：

PIA

全面的AI聚合平台，一站式访问所有顶级AI模型

226 查看详情 PIA

模板方法 (Template Method)：这是一个非虚函数，或者说是final函数，它定义了算法的步骤序列。它通常会调用一系列其他操作，这些操作有些是虚函数，有些可能是钩子方法，甚至是一些私有的辅助方法。这个方法是不可被子类重写的，确保了算法的整体流程不会被破坏。
基本操作 (Primitive Operations)：这些是虚函数，通常是纯虚函数（
```
= 0
```
），它们代表了算法中需要由子类来实现的具体步骤。基类只声明它们，不提供具体实现，将实现细节推迟到子类。
钩子方法 (Hook Methods)：这些也是虚函数，但它们通常提供一个默认的空实现或默认行为。子类可以选择性地覆盖它们，以在算法的特定点插入自己的代码，或者改变默认行为。它们提供了灵活性，允许子类在不修改模板方法结构的情况下进行微调。
具体子类 (Concrete Subclass)：它们继承自抽象基类，并实现所有纯虚的基本操作。它们是算法中可变部分的具体实现者。通过重写这些方法，每个子类都能提供一套独特的行为，但都遵循基类定义的整体流程。

我个人觉得，理解这些构成要素之间的关系至关重要。模板方法像是一个指挥家，协调着各个基本操作的执行顺序，而子类则是具体的演奏者，负责演绎出不同的乐章。钩子方法则像是在乐章中留下的即兴发挥空间，让演奏者可以根据需要加入自己的特色。

模板方法模式如何提升C++代码的复用性与可维护性？

谈到代码复用和可维护性，模板方法模式无疑是C++设计中一个强有力的工具。我曾经在处理一些业务流程相似但具体实现有差异的模块时，深感其妙用。

它提升复用性的核心在于将公共逻辑上移到基类。那些在不同子类中重复出现的、固定的算法步骤，被抽象并封装在基类的模板方法中。这意味着你不需要在每个子类中都重新编写这部分代码。比如我们造车的例子，

buildCar

的整体流程（设计、制造、安装、喷漆、测试）是固定的，无论造轿车还是SUV，这个流程都是一样的。我们只需要在基类中定义一次，所有子类都能直接复用。这大大减少了代码冗余，也降低了出错的可能性。当通用流程需要调整时，只需修改基类中的模板方法，所有子类都会自动继承这个改变，这简直是代码洁癖者的福音。

至于可维护性，它主要体现在“好莱坞原则”（Hollywood Principle）的实践上：“Don't call us, we'll call you.”（别打电话给我们，我们会打电话给你）。基类定义了算法的骨架，它在适当的时候调用子类实现的基本操作。这意味着子类不需要知道基类的具体实现细节，它只需要关心如何实现自己的那部分逻辑。这种松耦合的设计使得系统更容易理解和修改。当需求变化时，通常只需要修改或添加新的子类，而无需触碰基类，从而降低了引入bug的风险。

想象一下，如果有一天我们需要引入一个新的汽车型号，比如电动车。我们只需要创建一个

ElectricCarBuilder

子类，并实现其特有的

designCar

installEngine

(可能是安装电池和电动机) 等方法，而

buildCar

的整体流程仍然保持不变。这种扩展性，在我看来，是其维护优势的直接体现。它使得系统结构清晰，职责明确，为

以上就是C++模板方法模式与代码复用实现的详细内容，更多请关注知识资源分享宝库其它相关文章！

相关标签：代码复用工具 ai c++ ios silver 封装子类继承虚函数纯虚函数 class 算法 bug 大家都在看： C++如何使用模板实现迭代器类 C++如何处理复合对象中的嵌套元素 C++如何使用const修饰变量 C++如何使用ofstream和ifstream组合操作文件 C++循环与算法结合减少复杂度提升速度