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

UML类图:

代码实现

#include <stdio.h>
#include <stdlib.h>

// 产品类
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->product->part1 = malloc(sizeof(char) * (strlen(value) + 1));
    strcpy(builder->product->part1, value);
}

void ConcreteBuilder_buildPart2(void* obj, const char* value) {
    ConcreteBuilder* builder = (ConcreteBuilder*)obj;
    builder->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(&director, (Builder*)&builder);

    product = builder.getResult(&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;
}

在上面的示例代码中,首先定义了产品类Product,其中包含了三个部分然后定义抽象建造者类Builder,其中包含了构建产品的各个部分函数指针

接着定义了具体建造者类ConcreteBuilder,它实现抽象建造者类中函数,并拥有一个指向产品对象的指针。具体建造者类通过实现不同的构建方法来构建产品的不同部分,并提供获取最终产品的函数

最后定义了指挥者类Director,它接收一个具体建造者对象作为参数通过调用具体建造者的函数来构建产品。

main函数中,创建了具体建造者对象builder和指挥者对象director然后通过指挥者对象来构建产品。最后获取并打印产品的各个部分

建造者模式将产品的构建过程与产品的表示分离,使得构建过程可以独立于产品而变化。通过使用建造者模式,可以更加灵活地构建复杂对象,并且可以复用相同的构建过程来创建不同的产品。

建造者模式的优点:

  1. 可以将复杂对象的创建过程分解为多个简单步骤,使得代码更加清晰、易于维护和扩展

  2. 可以复用相同的构建过程来创建不同的产品,具有良好的灵活性。

  3. 可以控制产品对象的创建过程,保证其完整性和一致性

  4. 可以隐藏产品的内部实现细节,使得客户端需要关心产品的接口

建造者模式的缺点:

  1. 建造者模式中会增加很多类,导致代码量增加。

  2. 如果产品的组成部分发生变化,可能需要修改建造者类的代码,影响系统的稳定性。

适用场景

  1. 需要创建复杂的对象,而且对象的构建过程是稳定的,但是具体的构建步骤可能会有所差异。

  2. 需要创建多个相似但不同的对象,可以使用同一个构建过程来构建不同的对象。

  3. 需要控制对象的创建过程,并且希望隐藏产品的创建细节,只暴露出产品的接口

  4. 当产品的构成部分需要动态变化时,可以使用建造者模式。

原文地址:https://blog.csdn.net/qq_32059343/article/details/134629578

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任

如若转载,请注明出处:http://www.7code.cn/show_26980.html

如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱suwngjj01@126.com进行投诉反馈,一经查实,立即删除

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注