一文搞懂怎么用C语言实现模板方法模式_独钓渔的技术博客 ...

模板方法模式是行为型设计模式中的经典，它通过定义一个算法的框架，将一些固定流程封装在父类中，而将可变的步骤抽象为子类需要实现的方法。本文将通过C语言示例，带您理解如何实现该模式，以及它在实际开发中的应用价值与优势。

模板方法模式的核心思想

模板方法模式是一种行为型设计模式，其核心思想是将算法的固定流程封装在父类中，而将可变的步骤抽象为子类实现的方法。这意味着，父类定义了整体的执行逻辑，子类则负责实现其中某些步骤的细节。这与面向对象编程中“对扩展开放，对修改关闭”的原则相吻合。

在实际开发中，模板方法模式广泛用于框架开发、库设计和业务逻辑的统一管理。例如，一个图形渲染引擎可能有固定的绘制流程，但具体的绘制操作（如着色、纹理处理）由子类实现。这不仅提高了代码的复用性，还增强了系统的可维护性和可扩展性。

C语言中的模板方法模式实现

C语言虽然不支持面向对象编程中的类和继承，但它仍然可以通过结构体和函数指针的方式，模拟出类似模板方法模式的行为。这种方式虽不如C++中的虚函数和继承那样直观，却能实现算法框架的统一和具体实现的分离。

在本文提供的示例中，通过定义一个抽象模板类 AbstractClass，其中包含了三个函数指针：templateMethod、primitiveMethod1 和 primitiveMethod2。这些函数指针分别对应模板方法和两个抽象方法。模板方法 templateMethod 在父类中被定义为固定逻辑，它调用了两个抽象方法 primitiveMethod1 和 primitiveMethod2，而这些抽象方法的具体实现则由子类完成。

具体实现类 ConcreteClassA 和 ConcreteClassB 继承了 AbstractClass 的结构体，但它们在初始化时，分别实现了自己的 primitiveMethod1 和 primitiveMethod2。这样，父类的模板方法始终按照既定的逻辑执行，而子类可以根据自身需求进行扩展或修改具体实现。

模板方法模式的结构与实现细节

抽象类的设计

在C语言中，抽象类的概念是通过结构体和函数指针来实现的。AbstractClass 结构体中定义了两个关键函数指针：templateMethod 用于定义固定的算法流程，而 primitiveMethod1 和 primitiveMethod2 则用于抽象出可变的步骤。这种设计方式使得子类可以继承父类的结构体，并在初始化时覆盖这些函数指针的实现。

typedef struct class {
    void (*templateMethod)(struct class *this);
    void (*primitiveMethod1)(struct class *this);
    void (*primitiveMethod2)(struct class *this);
} AbstractClass;

具体实现类的定义

具体实现类 ConcreteClassA 和 ConcreteClassB 都是 AbstractClass 的子类。它们通过继承 AbstractClass 的结构体，并在初始化时绑定具体的实现函数，从而形成完整的对象。

typedef struct {
    AbstractClass base;
} ConcreteClassA;

typedef struct {
    AbstractClass base;
} ConcreteClassB;

模板方法的实现

在C语言中，templateMethod 是一个固定执行流程的函数指针，它负责调用两个抽象方法 primitiveMethod1 和 primitiveMethod2。这部分逻辑在父类中实现，子类无法修改，从而保证了算法框架的稳定性。

static void templateMethodImplementation(AbstractClass *template) {
    printf("Executing common logic...\n");
    template->primitiveMethod1(template);
    template->primitiveMethod2(template);
    printf("Executing common finalization...\n");
}

抽象方法的实现

primitiveMethod1 和 primitiveMethod2 是两个抽象方法，它们的实现由子类完成。在本文的示例中，具体实现类分别实现了自己的版本，这样即使不同的子类有不同的行为，它们仍然遵循相同的调用顺序和流程。

void primitiveMethodA1(AbstractClass *template) {
    printf("Specific logic for primitiveMethodA1 operation...\n");
}

void primitiveMethodA2(AbstractClass *template) {
    printf("Specific logic for primitiveMethodA2 operation...\n");
}

void primitiveMethodB1(AbstractClass *template) {
    printf("Specific logic for primitiveMethodB1 operation...\n");
}

void primitiveMethodB2(AbstractClass *template) {
    printf("Specific logic for primitiveMethodB2 operation...\n");
}

初始化函数的作用

为了使具体实现类能够使用父类的模板方法，需要通过初始化函数（如 createConcreteClassA 和 createConcreteClassB）将抽象方法绑定到具体的实现函数上。这一步是C语言模拟模板方法模式的关键。

void createConcreteClassA(ConcreteClassA *classA) {
    if (!classA)
        return;

    classA->base.templateMethod = templateMethodImplementation;
    classA->base.primitiveMethod1 = primitiveMethodA1;
    classA->base.primitiveMethod2 = primitiveMethodA2;
    printf("Initial ConcreteClassA...\n");
}

void createConcreteClassB(ConcreteClassB *classB) {
    if (!classB)
        return;

    classB->base.templateMethod = templateMethodImplementation;
    classB->base.primitiveMethod1 = primitiveMethodB1;
    classB->base.primitiveMethod2 = primitiveMethodB2;
    printf("Initial ConcreteClassB...\n");
}

主函数的调用逻辑

在主函数中，创建了两个具体实现对象 ConcreteClassA 和 ConcreteClassB，并通过 createConcreteClassA 和 createConcreteClassB 初始化它们的抽象方法。最后，通过调用 templateMethod 函数，触发整个算法流程。

int main() {
    ConcreteClassA ConcreteClassA;
    ConcreteClassB ConcreteClassB;

    createConcreteClassA(&ConcreteClassA);
    createConcreteClassB(&ConcreteClassB);

    ConcreteClassA.base.templateMethod((AbstractClass *)&ConcreteClassA);
    ConcreteClassB.base.templateMethod((AbstractClass *)&ConcreteClassB);

    return 0;
}

模板方法模式的优缺点

优点

1. 算法框架统一：模板方法模式将算法的固定流程封装在父类中，避免了重复代码。
2. 代码复用：子类不需要重新实现整个算法，只需实现部分抽象方法即可。
3. 扩展性强：通过子类实现抽象方法，可以灵活地扩展功能，而无需修改父类。
4. 遵循开闭原则：父类的算法框架不能被修改，只能通过子类扩展，符合面向对象设计的开闭原则。
5. 依赖倒置：父类通过接口调用子类的实现，而不是直接依赖具体实现，提高了系统的解耦程度。

缺点

1. 灵活性受限：由于模板方法不能被子类修改，某些情况下难以应对复杂的业务逻辑变化。
2. 调试复杂：函数指针的使用可能会增加调试的难度，特别是当实现逻辑较为复杂时。
3. 代码结构不清晰：C语言中没有类和继承的语法，结构体和函数指针的组合可能让代码结构显得不够直观。
4. 缺乏封装性：在C语言中，函数指针的绑定和调用是显式的，缺乏面向对象中的封装机制。

模板方法模式与C++设计模式的对比

在C++中，模板方法模式通常通过虚函数和继承来实现，而C语言则通过结构体和函数指针来模拟。虽然两者实现方式不同，但核心思想是一致的：将固定的逻辑放在父类中，可变的逻辑放在子类中。

C++的实现方式更为直观，通过继承和虚函数可以自然地实现模板方法模式。例如，定义一个抽象类 AbstractClass，其中包含一个纯虚函数 primitiveMethod1 和 primitiveMethod2，以及一个非虚的模板方法 templateMethod。子类通过重写这些纯虚函数，实现自己的逻辑，而模板方法则保持不变。

class AbstractClass {
public:
    virtual void primitiveMethod1() = 0;
    virtual void primitiveMethod2() = 0;
    void templateMethod() {
        printf("Executing common logic...\n");
        primitiveMethod1();
        primitiveMethod2();
        printf("Executing common finalization...\n");
    }
};

class ConcreteClassA : public AbstractClass {
public:
    void primitiveMethod1() override {
        printf("Specific logic for primitiveMethodA1 operation...\n");
    }

    void primitiveMethod2() override {
        printf("Specific logic for primitiveMethodA2 operation...\n");
    }
};

C++的实现方式更加符合面向对象编程的思想，代码结构也更为清晰。然而，C语言的实现方式也有其独特的优势，例如更高的灵活性和更轻量的依赖。

模板方法模式的应用场景

模板方法模式非常适合用于算法框架的定义和实现分离的场景。以下是一些常见的应用场景：

1. 框架开发：在开发一个通用框架时，可以将框架的核心逻辑（如初始化、处理、清理）定义为模板方法，而将具体实现留给子类。
2. 库设计：设计一个库时，可以通过模板方法模式提供统一的接口，而将具体实现细节隐藏起来。
3. 业务逻辑的统一管理：当多个子类有相同的业务流程，但某些步骤的实现不同，可以通过模板方法模式统一管理这些流程。
4. 测试用例管理：在单元测试中，可以使用模板方法模式来定义测试流程，而将具体的测试逻辑留给子类实现。

模板方法模式的进阶技巧

在C语言中使用模板方法模式时，可以结合一些进阶技巧来提升代码的可维护性和灵活性。

1. 使用函数指针数组

为了更好地管理多个抽象方法，可以使用函数指针数组，将所有抽象方法集中在一个数组中，方便后续的调用和扩展。

typedef void (*PrimitiveFunction)(AbstractClass *template);

PrimitiveFunction primitiveFunctions[] = {
    primitiveMethodA1,
    primitiveMethodA2,
    primitiveMethodB1,
    primitiveMethodB2
};

2. 使用宏简化代码

为了减少重复代码，可以使用宏来简化函数指针的绑定和调用过程。这在C语言中尤为有用，可以提高代码的可读性和可维护性。

#define BIND_PRIMITIVE_METHOD(name, func) \
    classA->base.name = func;

void createConcreteClassA(ConcreteClassA *classA) {
    if (!classA)
        return;

    BIND_PRIMITIVE_METHOD(primitiveMethod1, primitiveMethodA1);
    BIND_PRIMITIVE_METHOD(primitiveMethod2, primitiveMethodA2);
    classA->base.templateMethod = templateMethodImplementation;
    printf("Initial ConcreteClassA...\n");
}

3. 使用静态初始化

在C语言中，可以通过静态初始化来简化对象的创建和初始化过程，提高代码的可读性。

ConcreteClassA ConcreteClassA = {
    .base = {
        .templateMethod = templateMethodImplementation,
        .primitiveMethod1 = primitiveMethodA1,
        .primitiveMethod2 = primitiveMethodA2
    }
};

4. 使用结构体嵌套

为了更好地组织代码，可以使用结构体嵌套的方式，将抽象类和具体实现类组织成一个清晰的层次结构。

typedef struct {
    AbstractClass base;
    int someData;
} ConcreteClassA;

5. 使用函数指针的封装

为了提高代码的可读性，可以将函数指针封装成一个结构体或枚举，方便后续的调用和管理。

typedef struct {
    AbstractClass base;
    PrimitiveFunction primitiveMethods[2];
} ConcreteClassA;

模板方法模式的扩展与变体

1. 可变参数模板方法

在C++中，可以使用可变参数模板方法，实现更灵活的算法流程。例如，通过 template <typename... Args> 定义一个模板方法，支持多个参数的传递。

template <typename... Args>
void templateMethod(Args&&... args) {
    printf("Executing common logic...\n");
    primitiveMethod1();
    primitiveMethod2();
    printf("Executing common finalization...\n");
}

2. 策略模式的结合使用

策略模式与模板方法模式可以结合使用，以实现更复杂的逻辑控制。例如，通过策略模式选择不同的算法实现，再通过模板方法模式统一调用流程。

class Strategy {
public:
    virtual void execute() = 0;
};

class ConcreteStrategyA : public Strategy {
public:
    void execute() override {
        printf("Executing strategy A...\n");
    }
};

class ConcreteStrategyB : public Strategy {
public:
    void execute() override {
        printf("Executing strategy B...\n");
    }
};

3. 与工厂方法模式的结合

工厂方法模式与模板方法模式可以结合使用，以实现更灵活的对象创建和初始化。例如，通过工厂方法创建不同的实现类，再通过模板方法统一调用流程。

Strategy* createStrategyA() {
    return new ConcreteStrategyA();
}

Strategy* createStrategyB() {
    return new ConcreteStrategyB();
}

4. 模板方法模式的变体

除了基本的模板方法模式，还有多种变体，例如：

• 钩子方法（Hook Method）：允许子类在算法的某些步骤中插入自定义逻辑，增强灵活性。
• 混入（Mixin）：在C++中，可以通过继承多个类来实现混入功能，进一步扩展模板方法模式的应用。
• 模板方法与策略模式的结合：通过策略模式选择不同的算法实现，再通过模板方法统一调用流程。

总结

模板方法模式是一种经典的行为型设计模式，它通过封装固定流程、抽象可变步骤，实现了算法框架的统一和扩展的灵活性。在C语言中，虽然无法直接使用类和继承，但通过结构体和函数指针，仍然可以实现该模式。这种方式虽然不如C++中的实现方式直观，但具有更高的灵活性和更低的依赖。

在实际开发中，模板方法模式可以用于框架开发、库设计和业务逻辑的统一管理。它遵循开闭原则，使得系统更易于维护和扩展。同时，它还具备依赖倒置的特点，使得父类可以灵活地调用子类的具体实现，而不需要直接依赖具体实现。

通过本文的示例，可以看出C语言中实现模板方法模式的基本思路和实践技巧。对于初学者来说，这种方式虽然有一定的学习成本，但它能够帮助理解设计模式的核心思想，并为后续学习C++中的面向对象设计打下基础。

关键字

模板方法模式, C语言, 函数指针, 抽象类, 具体实现类, 开闭原则, 依赖倒置, 算法框架, 代码复用, 面向对象设计