構建器模式(Builder)的目標是將對象的創建與它的表示法分開，意味著創建過程保持原狀，但產生對象的表示法可能不同，它通常用來創建復雜的對象，這個對象是由多個組件組成的。
對于銷售組裝電腦的銷售商來說，他們要銷售電腦，而電腦通常由CPU、主板及硬盤等部件組成，這時，電腦的組成就可以由Builder模式來解決。
UML圖如下：
代碼如下：
//ComputerPart.h
#include <string>
class ComputerPart
{
public:
ComputerPart();
ComputerPart(std::string);
virtual ~ComputerPart();
friend std::ostream& operator<<(std::ostream& os, ComputerPart& part);
private:
std::string m_strPart;
};
//ComputerPart.cpp
#include "stdafx.h"
#include "ComputerPart.h"
#include <iostream>
using namespace std;
ComputerPart::ComputerPart()
{
}
ComputerPart::ComputerPart(string part)
{
m_strPart = part;
}
ComputerPart::~ComputerPart()
{
}
std::ostream& operator<<(std::ostream& os, ComputerPart& part)
{
return os << part.m_strPart << " ";
}
//DesktopProduct.h
#include <vector>
class ComputerPart;
class DesktopProduct
{
public:
DesktopProduct();
virtual ~DesktopProduct();
void AddPart(ComputerPart*);
friend std::ostream& operator<<(std::ostream& os, DesktopProduct& computer);
private:
std::vector<ComputerPart*> m_vParts;
};
//DesktopProduct.cpp
#include "stdafx.h"
#include "DesktopProduct.h"
#include "ComputerPart.h"
#include <iostream>
#include <typeinfo>
using namespace std;
DesktopProduct::DesktopProduct()
{
}
DesktopProduct::~DesktopProduct()
{
}
void DesktopProduct::AddPart(ComputerPart* pPart)
{
m_vParts.push_back(pPart);
}
ostream& operator<<(ostream& os, DesktopProduct& computer)
{
vector<ComputerPart*>::iterator it;
for(it = computer.m_vParts.begin(); it != computer.m_vParts.end(); ++it)
{
os << **it;
}
return os;
}
//Builder.h
class DesktopProduct;
class Builder
{
public:
Builder();
virtual ~Builder();
virtual void BuilderCPU() = 0;
virtual void BuilderMainboard() = 0;
virtual void BuilderHarddisk() = 0;
void CreateComputer();
DesktopProduct* GetComputer();
protected:
DesktopProduct* m_pComputer;
};
//Builder.cpp
#include "stdafx.h"
#include "Builder.h"
#include "DesktopProduct.h"
Builder::Builder()
{
m_pComputer = 0;
}
Builder::~Builder()
{
}
void Builder::CreateComputer()
{
m_pComputer = new DesktopProduct;
}
DesktopProduct* Builder::GetComputer()
{
return m_pComputer;
}
//DesktopBuilder.h
#include "Builder.h"
class DesktopBuilder : public Builder
{
public:
DesktopBuilder();
virtual ~DesktopBuilder();
void BuilderCPU();
void BuilderMainboard();
void BuilderHarddisk();
};
//DesktopBuilder.cpp
#include "stdafx.h"
#include "DesktopBuilder.h"
#include "DesktopProduct.h"
#include "ComputerPart.h"
#include <string>
using namespace std;
DesktopBuilder::DesktopBuilder()
{
}
DesktopBuilder::~DesktopBuilder()
{
}
void DesktopBuilder::BuilderCPU()
{
m_pComputer->AddPart(new ComputerPart("CPU"));
}
void DesktopBuilder::BuilderHarddisk()
{
m_pComputer->AddPart(new ComputerPart("硬盤"));
}
void DesktopBuilder::BuilderMainboard()
{
m_pComputer->AddPart(new ComputerPart("主板"));
}
//Seller.h
class Builder;
class Seller
{
public:
Seller();
virtual ~Seller();
void SetBuilder(Builder*);
void Construct();
private:
Builder* m_pBuilder;
};
//Seller.cpp
#include "stdafx.h"
#include "Seller.h"
#include "Builder.h"
Seller::Seller()
{
m_pBuilder = 0;
}
Seller::~Seller()
{
}
void Seller::SetBuilder(Builder* pBuilder)
{
m_pBuilder = pBuilder;
}
void Seller::Construct()
{
m_pBuilder->CreateComputer();
m_pBuilder->BuilderCPU();
m_pBuilder->BuilderHarddisk();
m_pBuilder->BuilderMainboard();
}
//main.cpp
#include "stdafx.h"
#include "Builder.h"
#include "DesktopBuilder.h"
#include "Seller.h"
#include "DesktopProduct.h"
#include <iostream>
using namespace std;
int main(int argc, char* argv[])
{
Builder* pBuilder = new DesktopBuilder;
Seller* pSeller = new Seller;
pSeller->SetBuilder(pBuilder);
pSeller->Construct();
cout << "組裝一臺電腦，由下列部件組成：\n" << *(pBuilder->GetComputer()) << endl;
return 0;
}
最后輸出為：
組裝一臺電腦，由下列部件組成：
CPU 硬盤 主板
該例中，產品臺式電腦（DesktopProduct）由CPU、硬盤及主板組成，它的組成過程是交給構建器（DesktopBuilder）來組合的，而構建器又是由電腦組裝人員（Seller）來進行操作，最終，電腦組裝人員組裝完成一電腦，然后銷售組客戶。