设计模式之建造者模式（建造者模式uml图）

介绍：

建造者模式是一种创建型设计模式，亦称创建者模式、生成器模式等；该模式是将一个复杂的对象分解为许多简单的对象，然后逐步构建出想要的产品，产品的最终形态都是一致的，但是具体组成的每个对象可能是不相同的；

优点：

• 将复杂对象的构建与表示分离；
• 只需要选择具体的组成对象即可创建出复杂的对象，无需知道建造细节；

类比：

一个台式机是由CPU、显卡、内存、硬盘等部件组成，我们可以根据自己的需求选择不同型号不同厂商的部件，比如说CPU选择Intel或者AMD的；在这里一个台式机就是由许多部件组成，每个组成部件都可能是不相同的，但是最终组成的都是一台台式机；

结构：

• 建造者(Builder)：指定创建产品不同组成部分的方法；
• 具体建造者(Concrete Builder)：实现Builder中的各个部件的具体创建方式；
• 指挥者(Director)：定义构造的步骤完成对复杂对象的创建；
• 产品(Products)：最终生成的对象；

代码示例：

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include "list.h"

static LIST_HEAD(computer_component);

typedef struct _Builder
{
    void (*cpu)(void);
    void (*gpu)(void);
    void (*display)(void);
    void (*show)(void);
} Computer_Builder;

typedef struct
{
    const char* name;
    const char* type;
} info_t;

typedef struct
{
    info_t info;
    ListObj list;
}cpu_t;


typedef struct
{
    info_t info;
    ListObj list;
}gpu_t;


typedef struct
{
    info_t info;
    ListObj list;
}display_t;


void Intel_cpu(void)
{
    cpu_t* intel_cpu = (cpu_t*)malloc(sizeof(cpu_t));
    assert(intel_cpu != NULL);
    memset(intel_cpu, 0, sizeof(cpu_t));
    intel_cpu->info.name = "Intel";
    intel_cpu->info.type = "9400F";
    list_insert_before(&computer_component, &intel_cpu->list);
}


void NVIDIA_gpu(void)
{
    gpu_t* nvidia_cpu = (gpu_t*)malloc(sizeof(gpu_t));
    assert(nvidia_cpu != NULL);
    memset(nvidia_cpu, 0, sizeof(gpu_t));
    nvidia_cpu->info.name = "NVIDIA";
    nvidia_cpu->info.type = "RTX2060";
    list_insert_before(&computer_component, &nvidia_cpu->list);
}


void Sony_display(void)
{
    display_t* sony_display = (display_t*)malloc(sizeof(display_t));
    assert(sony_display != NULL);
    memset(sony_display, 0, sizeof(display_t));
    sony_display->info.name = "SONY";
    sony_display->info.type = "SN-600";
    list_insert_before(&computer_component, &sony_display->list);
}


void show_computer(void)
{
    ListObj *component;
    list_for_each(component, &computer_component)
    {
        info_t* info = (info_t*)list_entry(component, cpu_t, list);
        printf("name: %s, type: %s\r\n", info->name, info->type);
    }
    printf("===========\r\n\n");
}


Computer_Builder ConcreteBuilder = {.cpu = Intel_cpu, .gpu = NVIDIA_gpu, .display = Sony_display, .show = show_computer};

typedef struct
{
    Computer_Builder* builder;
    void (*min_component)(Computer_Builder* builder);
} Director_t;

void computer_min_component(Computer_Builder* builder)
{
    builder->cpu();
}

void main(void)
{
    Director_t director = {.builder = &ConcreteBuilder, .min_component = computer_min_component};
    director.min_component(director.builder);
    director.builder->show();

    Computer_Builder* builder = &ConcreteBuilder;
    builder->gpu();
    builder->show();

    builder->display();
    builder->show();
}

代码中的链表操作是侵入式链表，和普通链表的作用是一样的，后续会专门出一篇文章介绍；