建造者模式-C语言实现

本文介绍: 建造者模式将产品的构建过程与产品的表示分离，使得构建过程可以独立于产品而变化。通过使用建造者模式，可以更加灵活地构建复杂对象，并且可以复用相同的构建过程来创建不同的产品。具体建造者类通过实现不同的构建方法来构建产品的不同部分，并提供获取最终产品的函数。需要创建复杂的对象，而且对象的构建过程是稳定的，但是具体的构建步骤可能会有所差异。如果产品的组成部分发生变化，可能需要修改建造者类的代码，影响系统的稳定性。需要控制对象的创建过程，并且希望隐藏产品的创建细节，只暴露出产品的接口。函数中，创建了具体建造者对象。

UML类图：

代码实现：

#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

// 产品类
typedef struct {
    char* part1;
    char* part2;
    char* part3;
} Product;

// 抽象建造者类
typedef struct {
    void (*buildPart1)(void*, const char*);
    void (*buildPart2)(void*, const char*);
    void (*buildPart3)(void*, const char*);
    Product* (*getResult)(void*);
} Builder;

// 具体建造者类
typedef struct {
    Product* product;
    void (*buildPart1)(void*, const char*);
    void (*buildPart2)(void*, const char*);
    void (*buildPart3)(void*, const char*);
    Product* (*getResult)(void*);
} ConcreteBuilder;

void ConcreteBuilder_buildPart1(void* obj, const char* value) {
    ConcreteBuilder* builder = (ConcreteBuilder*)obj;
    builder-&gt;product-&gt;part1 = malloc(sizeof(char) * (strlen(value) + 1));
    strcpy(builder-&gt;product-&gt;part1, value);
}

void ConcreteBuilder_buildPart2(void* obj, const char* value) {
    ConcreteBuilder* builder = (ConcreteBuilder*)obj;
    builder-&gt;product->part2 = malloc(sizeof(char) * (strlen(value) + 1));
    strcpy(builder->product->part2, value);
}

void ConcreteBuilder_buildPart3(void* obj, const char* value) {
    ConcreteBuilder* builder = (ConcreteBuilder*)obj;
    builder->product->part3 = malloc(sizeof(char) * (strlen(value) + 1));
    strcpy(builder->product->part3, value);
}

Product* ConcreteBuilder_getResult(void* obj) {
    ConcreteBuilder* builder = (ConcreteBuilder*)obj;
    return builder->product;
}

// 指挥者类
typedef struct {
    void (*construct)(void*, Builder*);
} Director;

void Director_construct(void* obj, Builder* builder) {
    Director* director = (Director*)obj;
    director->builder = builder;
    director->builder->buildPart1(director->builder, "Part 1");
    director->builder->buildPart2(director->builder, "Part 2");
    director->builder->buildPart3(director->builder, "Part 3");
}

int main() {
    ConcreteBuilder builder;
    Product* product;

    builder.product = malloc(sizeof(Product));
    builder.buildPart1 = ConcreteBuilder_buildPart1;
    builder.buildPart2 = ConcreteBuilder_buildPart2;
    builder.buildPart3 = ConcreteBuilder_buildPart3;
    builder.getResult = ConcreteBuilder_getResult;

    Director director;
    director.construct = Director_construct;
    director.construct(&amp;director, (Builder*)&amp;builder);

    product = builder.getResult(&amp;builder);

    printf("Part 1: %sn", product->part1);
    printf("Part 2: %sn", product->part2);
    printf("Part 3: %sn", product->part3);

    free(product->part1);
    free(product->part2);
    free(product->part3);
    free(product);
    
    return 0;
}