创建型模式：⑤构建器模式（Builder）

创建型模式：⑤构建器模式（Builder）

c语言写法

核心思想
将复杂对象的 “构建过程” 与 “表示” 分离，通过 “构建器” 分步组装部件，“指挥者” 控制构建流程（适合多部件、多配置的复杂对象）。
关键要点
1.分离关注点：
构建器（Builder）：负责 “组装部件”（如装 CPU、内存）。
指挥者（Director）：负责 “构建流程”（如先装 CPU 再装内存）。
2.优势：相同构建流程可创建不同配置的产品（游戏电脑 / 办公电脑），扩展新产品只需新增构建器，无需修改指挥者。

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

// -------------------------- 复杂产品：电脑 --------------------------
typedef struct Computer {
    char cpu[32];    // 部件1：CPU
    char memory[32]; // 部件2：内存
    char disk[32];   // 部件3：硬盘
    int price;       // 总价
    void (*destroy)(struct Computer*);
} Computer;

void computer_destroy(Computer* comp) {
    if (comp) {
        printf("销毁电脑：CPU=%s, 内存=%s, 硬盘=%s\n", comp->cpu, comp->memory, comp->disk);
        free(comp);
    }
}

// -------------------------- 构建器接口（抽象构建器）--------------------------
typedef struct Builder {
    Computer* product; // 正在构建的产品
    void (*set_cpu)(struct Builder*, const char*);    // 组装CPU
    void (*set_memory)(struct Builder*, const char*); // 组装内存
    void (*set_disk)(struct Builder*, const char*);   // 组装硬盘
    Computer* (*get_product)(struct Builder*);        // 获取成品
    void (*destroy)(struct Builder*);
} Builder;

// -------------------------- 具体构建器1：游戏电脑 --------------------------
void game_builder_set_cpu(Builder* self, const char* cpu) {
    strncpy(self->product->cpu, cpu, sizeof(self->product->cpu));
    self->product->price += 3000; // 游戏CPU加价
}

void game_builder_set_memory(Builder* self, const char* memory) {
    strncpy(self->product->memory, memory, sizeof(self->product->memory));
    self->product->price += 1500; // 大内存加价
}

void game_builder_set_disk(Builder* self, const char* disk) {
    strncpy(self->product->disk, disk, sizeof(self->product->disk));
    self->product->price += 1000; // 高速硬盘加价
}

Computer* game_builder_get_product(Builder* self) {
    return self->product;
}

Builder* create_game_builder() {
    Builder* builder = (Builder*)malloc(sizeof(Builder));
    builder->product = (Computer*)malloc(sizeof(Computer));
    memset(builder->product, 0, sizeof(Computer)); // 初始化产品
    builder->product->price = 0;
    builder->product->destroy = computer_destroy;

    builder->set_cpu = game_builder_set_cpu;
    builder->set_memory = game_builder_set_memory;
    builder->set_disk = game_builder_set_disk;
    builder->get_product = game_builder_get_product;
    builder->destroy = free;
    return builder;
}

// -------------------------- 具体构建器2：办公电脑 --------------------------
void office_builder_set_cpu(Builder* self, const char* cpu) {
    strncpy(self->product->cpu, cpu, sizeof(self->product->cpu));
    self->product->price += 1500; // 办公CPU加价
}

void office_builder_set_memory(Builder* self, const char* memory) {
    strncpy(self->product->memory, memory, sizeof(self->product->memory));
    self->product->price += 800; // 普通内存加价
}

void office_builder_set_disk(Builder* self, const char* disk) {
    strncpy(self->product->disk, disk, sizeof(self->product->disk));
    self->product->price += 500; // 普通硬盘加价
}

Computer* office_builder_get_product(Builder* self) {
    return self->product;
}

Builder* create_office_builder() {
    Builder* builder = (Builder*)malloc(sizeof(Builder));
    builder->product = (Computer*)malloc(sizeof(Computer));
    memset(builder->product, 0, sizeof(Computer));
    builder->product->price = 0;
    builder->product->destroy = computer_destroy;

    builder->set_cpu = office_builder_set_cpu;
    builder->set_memory = office_builder_set_memory;
    builder->set_disk = office_builder_set_disk;
    builder->get_product = office_builder_get_product;
    builder->destroy = free;
    return builder;
}

// -------------------------- 指挥者（控制构建流程）--------------------------
typedef struct Director {
    void (*construct)(struct Director*, Builder*); // 固定构建步骤
} Director;

// 指挥者定义构建流程：CPU → 内存 → 硬盘（固定顺序）
void director_construct(Director* self, Builder* builder) {
    builder->set_cpu(builder, "Intel i5");    // 步骤1：装CPU
    builder->set_memory(builder, "16GB DDR4");// 步骤2：装内存
    builder->set_disk(builder, "512GB SSD");  // 步骤3：装硬盘
}

Director* create_director() {
    Director* director = (Director*)malloc(sizeof(Director));
    director->construct = director_construct;
    return director;
}

void destroy_director(Director* director) {
    free(director);
}

// 测试代码
int main() {
    // 1. 创建指挥者（控制流程）
    Director* director = create_director();

    // 2. 构建游戏电脑
    Builder* game_builder = create_game_builder();
    director->construct(director, game_builder); // 指挥构建
    Computer* game_pc = game_builder->get_product(game_builder);
    printf("游戏电脑：CPU=%s, 内存=%s, 硬盘=%s, 价格=%d元\n",
           game_pc->cpu, game_pc->memory, game_pc->disk, game_pc->price);

    // 3. 构建办公电脑
    Builder* office_builder = create_office_builder();
    director->construct(director, office_builder); // 复用相同流程
    Computer* office_pc = office_builder->get_product(office_builder);
    printf("办公电脑：CPU=%s, 内存=%s, 硬盘=%s, 价格=%d元\n",
           office_pc->cpu, office_pc->memory, office_pc->disk, office_pc->price);

    // 4. 资源释放
    game_pc->destroy(game_pc);
    office_pc->destroy(office_pc);
    game_builder->destroy(game_builder);
    office_builder->destroy(office_builder);
    destroy_director(director);

    return 0;
}

c++语言写法

核心思想
分离复杂对象的 构建过程（Director） 和 部件组装（Builder），Builder 负责组装部件，Director 控制构建顺序，支持创建不同配置的复杂对象。
关键要点
1.职责分离：
Builder：负责 “怎么装”（组装 CPU、内存等部件，定义部件配置和价格）。
Director：负责 “装什么顺序”（固定构建流程，客户端无需关心步骤）。
2.灵活扩展：新增产品（如设计电脑）只需新增 DesignBuilder 类，复用 Director 的构建流程，符合开闭原则。
3.所有权转移：GetProduct() 用 std::move 转移产品所有权，避免浅拷贝和内存泄漏。

#include <iostream>
#include <string>
#include <memory>

// -------------------------- 复杂产品：Computer --------------------------
class Computer {
public:
    void SetCPU(const std::string& cpu) { cpu_ = cpu; }
    void SetMemory(const std::string& memory) { memory_ = memory; }
    void SetDisk(const std::string& disk) { disk_ = disk; }
    void SetPrice(int price) { price_ = price; }

    void ShowInfo() const {
        std::cout << "电脑配置：CPU=" << cpu_ 
                  << ", 内存=" << memory_ 
                  << ", 硬盘=" << disk_ 
                  << ", 价格=" << price_ << "元" << std::endl;
    }

private:
    std::string cpu_;
    std::string memory_;
    std::string disk_;
    int price_ = 0;
};

// -------------------------- 抽象构建器（Builder）--------------------------
class Builder {
public:
    virtual ~Builder() = default;
    // 纯虚接口：组装各个部件
    virtual void BuildCPU() = 0;
    virtual void BuildMemory() = 0;
    virtual void BuildDisk() = 0;
    // 返回构建完成的产品
    virtual std::unique_ptr<Computer> GetProduct() = 0;

protected:
    // 保护成员：供子类访问产品
    std::unique_ptr<Computer> product_ = std::make_unique<Computer>();
};

// -------------------------- 具体构建器1：游戏电脑构建器 --------------------------
class GameBuilder : public Builder {
public:
    void BuildCPU() override {
        product_->SetCPU("Intel i7");
        product_->SetPrice(product_->price_ + 3000); // 游戏CPU加价
    }

    void BuildMemory() override {
        product_->SetMemory("32GB DDR5");
        product_->SetPrice(product_->price_ + 2000); // 大内存加价
    }

    void BuildDisk() override {
        product_->SetDisk("1TB SSD");
        product_->SetPrice(product_->price_ + 1500); // 高速硬盘加价
    }

    std::unique_ptr<Computer> GetProduct() override {
        return std::move(product_); // 转移产品所有权
    }
};

// -------------------------- 具体构建器2：办公电脑构建器 --------------------------
class OfficeBuilder : public Builder {
public:
    void BuildCPU() override {
        product_->SetCPU("Intel i5");
        product_->SetPrice(product_->price_ + 1500); // 办公CPU加价
    }

    void BuildMemory() override {
        product_->SetMemory("16GB DDR4");
        product_->SetPrice(product_->price_ + 800); // 普通内存加价
    }

    void BuildDisk() override {
        product_->SetDisk("512GB SSD");
        product_->SetPrice(product_->price_ + 500); // 普通硬盘加价
    }

    std::unique_ptr<Computer> GetProduct() override {
        return std::move(product_);
    }
};

// -------------------------- 指挥者（Director）：控制构建流程 --------------------------
class Director {
public:
    // 固定构建顺序：CPU → 内存 → 硬盘
    void Construct(Builder& builder) {
        builder.BuildCPU();
        builder.BuildMemory();
        builder.BuildDisk();
    }
};

// 测试代码
int main() {
    // 1. 创建指挥者（控制流程）
    Director director;

    // 2. 构建游戏电脑
    GameBuilder game_builder;
    director.Construct(game_builder); // 指挥构建
    auto game_pc = game_builder.GetProduct();
    std::cout << "=== 游戏电脑 ===" << std::endl;
    game_pc->ShowInfo();

    // 3. 构建办公电脑（复用指挥者流程）
    OfficeBuilder office_builder;
    director.Construct(office_builder);
    auto office_pc = office_builder.GetProduct();
    std::cout << "\n=== 办公电脑 ===" << std::endl;
    office_pc->ShowInfo();

    return 0;
}