建造者模式（C++实现）

（本博客旨在个人总结回顾）

1、详情：

建造者模式：将一个复杂对象与它的表示分离，使得同样的构建过程可以创建不同的表示。

优点： ①建造者独立，易扩展。 ②便于控制细节风险。

缺点： ①产品必须有共同点，范围有限制。 ②如内部变化复杂，会有很多的建造类。

使用场景： ①需要生成的对象具有复杂的内部结构。 ②需要生成的对象内部属性本身相互依赖。

注意事项：与抽象工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

2、应用实例：

快餐店汉堡与饮料组成的套餐，

2.1、UML类图：

 

2.2、代码实现：

Packing.h

#pragma once
#include <string>
using std::string;

class Packing
{
public:
    Packing();
    virtual ~Packing();

public:
    virtual string pack() = 0;
};

Packing.cpp

#include "stdafx.h"
#include "Packing.h"

Packing::Packing()
{
}

Packing::~Packing()
{
}

Wrapper.h

#pragma once
#include "Packing.h"

class Wrapper: public Packing
{
public:
    Wrapper();
    ~Wrapper();

public:
    string pack();
};

Wrapper.cpp

#include "stdafx.h"
#include "Wrapper.h"

Wrapper::Wrapper()
{
}

Wrapper::~Wrapper()
{
}

string Wrapper::pack()
{
    return "Wrapper";
}

Bottle.h

#pragma once
#include "Packing.h"

class Bottle : public Packing
{
public:
    Bottle();
    ~Bottle();

public:
    string pack();
};

Bottle.cpp

#include "stdafx.h"
#include "Bottle.h"

Bottle::Bottle()
{
}

Bottle::~Bottle()
{
}

string Bottle::pack()
{
    return "Bottle";
}

FoodItem.h(抽象产品类)

#pragma once
#include "Packing.h"
#include <string>
using std::string;

class FoodItem
{
public:
    FoodItem();
    virtual ~FoodItem();

public:
    virtual string name() = 0;
    virtual Packing* packing() = 0;
    virtual double price() = 0;
};

FoodItem.cpp

#include "stdafx.h"
#include "FoodItem.h"

FoodItem::FoodItem()
{
}

FoodItem::~FoodItem()
{
}

Burger.h（产品类1）

#pragma once
#include "FoodItem.h"
#include "Wrapper.h"

class Burger :public FoodItem
{
public:
    Burger();
    ~Burger();

public:
    Packing* packing();

private:
    Packing* m_pPacking;
};

Burger.cpp

#include "stdafx.h"
#include "Burger.h"

Burger::Burger()
    : m_pPacking(NULL)
{
}

Burger::~Burger()
{
    if (NULL == m_pPacking)
    {
        delete m_pPacking;
        m_pPacking = NULL;
    }
}

Packing* Burger::packing()
{
    if (NULL == m_pPacking)
    {
        m_pPacking = new Wrapper();
    }

    return m_pPacking;
}

VegBurger.h（具体产品）

#pragma once
#include "Burger.h"

class VegBurger : public Burger
{
public:
    VegBurger();
    virtual ~VegBurger();

public:
    string name();
    double price();
};

VegBurger.cpp

#include "stdafx.h"
#include "VegBurger.h"

VegBurger::VegBurger()
{
}

VegBurger::~VegBurger()
{
}

string VegBurger::name()
{
    return "Veg Burger";
}

double VegBurger::price()
{
    return 23.5f;
}

ChickenBurger.h（具体产品）

#pragma once
#include "Burger.h"

class ChickenBurger : public Burger
{
public:
    ChickenBurger();
    ~ChickenBurger();

public:
    string name();
    double price();
};

ChickenBurger.cpp

#include "stdafx.h"
#include "ChickenBurger.h"

ChickenBurger::ChickenBurger()
{
}

ChickenBurger::~ChickenBurger()
{
}

string ChickenBurger::name()
{
    return "Chicken Burger";
}

double ChickenBurger::price()
{
    return 28.0f;
}

Drink.h（产品类2）

#pragma once
#include "FoodItem.h"
#include "Bottle.h"

class Drink : public FoodItem
{
public:
    Drink();
    ~Drink();

public:
    Packing* packing();

private:
    Packing* m_pPacking;
};

Drink.cpp

#include "stdafx.h"
#include "Drink.h"

Drink::Drink()
    : m_pPacking(NULL)
{
}

Drink::~Drink()
{
    if (NULL == m_pPacking)
    {
        delete m_pPacking;
        m_pPacking = NULL;
    }
}

Packing* Drink::packing()
{
    if (NULL == m_pPacking)
    {
        m_pPacking = new Bottle();
    }

    return m_pPacking;
}

Coke.h（具体产品）

#pragma once
#include "Drink.h"

class Coke :public Drink
{
public:
    Coke();
    ~Coke();

public:
    string name();
    double price();
};

Coke.cpp

#include "stdafx.h"
#include "Coke.h"

Coke::Coke()
{
}

Coke::~Coke()
{
}

string Coke::name()
{
    return "Coke";
}

double Coke::price()
{
    return 8.8f;
}

Pepsi.h（具体产品）

#pragma once
#include "Drink.h"

class Pepsi :public Drink
{
public:
    Pepsi();
    ~Pepsi();

public:
    string name();
    double price();
};

Pepsi.cpp

#include "stdafx.h"
#include "Pepsi.h"

Pepsi::Pepsi()
{
}

Pepsi::~Pepsi()
{
}

string Pepsi::name()
{
    return "Pepsi";
}

double Pepsi::price()
{
    return 7.9f;
}

Meal.h

#pragma once
#include "FoodItem.h"
#include <iostream>
#include <list>
using namespace std;

class Meal
{
public:
    Meal();
    ~Meal();
public:
    void addItem(FoodItem* pFoodItem);
    double getCost();
    void showFoodItems();

private:
    std::list<FoodItem*> m_listFoodItem;
};

Meal.cpp

#include "stdafx.h"
#include "Meal.h"

Meal::Meal()
{
}

Meal::~Meal()
{
    for (std::list<FoodItem*>::iterator it = m_listFoodItem.begin(); it != m_listFoodItem.end(); it++)
    {
        FoodItem* pFoodItem = (*it);
        delete pFoodItem;
    }
}

void Meal::addItem(FoodItem* pFoodItem)
{
    m_listFoodItem.push_back(pFoodItem);
}

double Meal::getCost()
{
    double cost = 0.0f;
    for (std::list<FoodItem*>::iterator it = m_listFoodItem.begin(); it != m_listFoodItem.end(); it++)
    {
        cost += (*it)->price();
    }
    return cost;
}

void Meal::showFoodItems()
{
    cout << "Meal:" << endl;
    for (std::list<FoodItem*>::iterator it = m_listFoodItem.begin(); it != m_listFoodItem.end(); it++)
    {
        cout << "FoodItem:" << (*it)->name() 
        << ",Packing:" << (*it)->packing()->pack() 
        << ",price:" << (*it)->price() << endl;
    }
    cout << "cost:" << getCost() << endl;
}

MealBuilder.h（建造者类）

#pragma once
#include "Meal.h"
#include "VegBurger.h"
#include "ChickenBurger.h"
#include "Coke.h"
#include "Pepsi.h"

class MealBuilder
{
public:
    MealBuilder();
    ~MealBuilder();

public:
    Meal* prepareVegMeal();
    Meal* prepareNovegMeal();
};

MealBuilder.cpp

#include "stdafx.h"
#include "MealBuilder.h"

MealBuilder::MealBuilder()
{
}

MealBuilder::~MealBuilder()
{
}

Meal* MealBuilder::prepareVegMeal()
{
    Meal* pMeal = new Meal();
    pMeal->addItem(new VegBurger());
    pMeal->addItem(new Coke());
    return pMeal;
}

Meal* MealBuilder::prepareNovegMeal()
{
    Meal* pMeal = new Meal();
    pMeal->addItem(new ChickenBurger());
    pMeal->addItem(new Pepsi());
    return pMeal;
}

调用代码：

// BuilderPattern.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "MealBuilder.h"
#include <iostream>
#include <string>
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    MealBuilder mealBuilder;
    Meal* pMeal = mealBuilder.prepareVegMeal();
    pMeal->showFoodItems();
    delete pMeal;
    pMeal = NULL;

    pMeal = mealBuilder.prepareNovegMeal();
    pMeal->showFoodItems();
    delete pMeal;
    pMeal = NULL;

    system("pause");
	return 0;
}

输出结果：