/ 一、簡介 /

建造者模式: 也稱生成器模式，是 23 種設計模式中的一種，是一種創建型模式。適用情況：一個對象比較復雜，將一個對象的構建和對象的表示進行分離。

比較：與工廠模式進行對比，工廠模式不考慮對象部件組裝過程，直接生成一個最終的對象，強調的是 結果 。而建造者模式先構建對象的每一個部件，然后再統一組建成一個對象，強調的是 過程 。

目的：實現復雜對象的生產流程與部件進行解耦。

/ 二、設計實現 /

以建造房子為例，房子有公寓、別墅、樓房等類型，雖然是不同種類的房子，但其建造過程大體上都相同，例如都有這些流程：修建墻、窗戶、門、地板、樓頂等。

我們實現 Builder( 建造者 )建房，因為都有修建（墻、窗戶、門、樓等）這些 部件 ，但是具體實現卻不同，所以我們需要把實現這些組建的操作給抽象出來，把每個部件實現了，然后再組裝起來，修建的房子就完成了。

typedef struct IBuilder_t           //建造者抽象接口
{
    void (*make_floor)(void *obj);  //修建地板
    void (*make_door)(void *obj);   //修建門
    void (*make_wall)(void *obj);   //修建墻
    void (*make_window)(void *obj); //修建窗
    void (*destory)(void *obj);     //釋放內存
    House_t *house;                 //house對象
}IBuilder_t;

定義房子對象，然后房子里面的部件(墻、窗、門、地板等)交給建造者設置修建。

typedef struct House_t  //定義房子要實現的接口
{
    void (*setfloor)(struct House_t* obj, char *floor);
    void (*setdoor)(struct House_t* obj, char *door);
    void (*setwall)(struct House_t* obj, char *wall);
    void (*setwindow)(struct House_t* obj, char *window);


    char floor[32];         //地板名字
    char door[32];          //門名字
    char wall[32];          //墻名字
    char window[32];        //窗名字
}House_t;


//修建的地板類型。
//static修飾，不讓外部直接調用這個函數，
//一般這些函數的實現放到.c文件中，結構體定義在.h文件中,
//而是通過House_t結構體的setfloor()函數指針進行調用，起到封裝效果(下同)。
static void house_setfloor(House_t* obj, char *floor)
{
    if(obj) sprintf(obj- >floor, "%s", floor);
}


//修建的門類型
static void house_setdoor(House_t* obj, char *door)
{
    if(obj) sprintf(obj- >door, "%s", door);
}


//修建的墻類型
static void house_setwall(House_t* obj, char *wall)
{
    if(obj) sprintf(obj- >wall, "%s", wall);
}


//修建的窗類型
static void house_setwindow(House_t* obj, char *window)
{
    if(obj) sprintf(obj- >window, "%s", window);
}


//構造函數 創建一個房子的對象
//此處這個函數不能適用static修飾
//該函數是要開放被外部調用的
House_t* constructor_house(void)
{
    House_t* house = (House_t*)malloc(sizeof(House_t)); //申請對象
    house- >setdoor = house_setdoor;    //函數指針賦值
    house- >setfloor = house_setfloor;  //函數指針賦值
    house- >setwall = house_setwall;    //函數指針賦值  
    house- >setwindow = house_setwindow;//函數指針賦值
    return house;                      //返回一個房子對象
}

接下來我們實現 builder，修建一個 公寓 。注：另外一個修建別墅實現，與修建公寓實現幾乎完全一致，此處不做過多闡述。

//建造公寓的結構體，與IBuilder_t定義一致，即對IBuilder_t的實現
typedef struct FlatBuilder_t 
{
    void (*make_floor)(void *obj);
    void (*make_door)(void *obj);
    void (*make_wall)(void *obj);
    void (*make_window)(void *obj);
    void (*destory)(void *obj);
    House_t *house;
}FlatBuilder_t;


//建造地板。static修飾作用同上
static void flat_make_floor(void *obj)
{
    FlatBuilder_t* flat = (FlatBuilder_t*)obj;
    flat- >house- >setfloor(flat- >house, "修建:flat floor");
}
//建造門
static void flat_make_door(void *obj)
{
    FlatBuilder_t* flat = (FlatBuilder_t*)obj;
    flat- >house- >setdoor(flat- >house, "修建:flat door");
}
//建造墻
static void flat_make_wall(void *obj)
{
    FlatBuilder_t* flat = (FlatBuilder_t*)obj;
    flat- >house- >setwall(flat- >house, "修建:flat wall");
}
//建造窗
static void flat_make_window(void *obj)
{
    FlatBuilder_t* flat = (FlatBuilder_t*)obj;
    flat- >house- >setwindow(flat- >house, "修建:flat window");
}
//釋放內存的函數
static void flat_destory(void *obj)
{
    FlatBuilder_t* flat = (FlatBuilder_t*)obj;
    if(flat- >house) free(flat- >house); //首先先釋放flat包含的house內存
    flat- >house=NULL;
    free(flat);                        //其次再釋放當前對象
    flat=NULL;
}


//公寓建造者的構造函數，此處不能采用static修飾，因為其要被外部調用
FlatBuilder_t* constructor_flat_builder(void)
{
    FlatBuilder_t* flat = (FlatBuilder_t*)malloc(sizeof(FlatBuilder_t));
    flat- >house = constructor_house();
    flat- >make_door = flat_make_door;
    flat- >make_floor = flat_make_floor;
    flat- >make_wall = flat_make_wall;
    flat- >make_window = flat_make_window;
    flat- >destory = flat_destory;
    return flat;
}

/ 三、測試 /

main 函數里面的測試代碼如下：定義一個 ** IBuilder_t buidler=NULL * ，用它指向不同的建造者，實現修建不同的房子。此時修建公寓和別墅兩種不同房子。

int main(void)
{
    House_t *house=NULL;
    IBuilder_t *buidler=NULL;


    //指向公寓建造者，修建公寓
    buidler=(IBuilder_t*)constructor_flat_builder();
    buidler- >make_door(buidler);  //修建公寓的門
    buidler- >make_floor(buidler); //修建公寓的地板
    buidler- >make_wall(buidler);  //修建公寓的墻
    buidler- >make_window(buidler);//修建公寓的窗
    house = buidler- >house;       //拿到修建的好的房子
    printf("%s\\n", house- >door);  //顯示公寓門
    printf("%s\\n", house- >floor); //顯示公寓地板
    printf("%s\\n", house- >wall);  //顯示公寓墻
    printf("%s\\n", house- >window);//顯示公寓窗
    buidler- >destory(buidler);    //釋放內存
    printf("\\n");


    //指向別墅建造者，修建別墅
    buidler=(IBuilder_t*)constructor_villa_builder();
    buidler- >make_door(buidler);    //修建別墅的門
    buidler- >make_floor(buidler);   //修建別墅的地板
    buidler- >make_wall(buidler);    //修建別墅的墻
    buidler- >make_window(buidler);  //修建別墅的窗
    house = buidler- >house;         //拿到修建好的房子
    printf("%s\\n", house- >door);    //顯示別墅門
    printf("%s\\n", house- >floor);   //顯示別墅地板
    printf("%s\\n", house- >wall);    //顯示別墅墻
    printf("%s\\n", house- >window);  //顯示別墅窗
    buidler- >destory(buidler);      //釋放內存


    return 0;
}

執行的效果如下圖：

/ 四、總結 /

通過上面的內容，我們了解到建造者模式主要是針對創建對象的過程的，而且還可以控制一個復雜類中部件創建的順序以及部件創建的內容。提高程序的擴展性，踐行“高內聚、低耦合”。