建造者模式
定義:將一個複雜對象的構造與他的表示分離,是同樣的構造過程可以創建不同的表示。可以想象爲先創建一個產品的骨架,再拼接他的零件。
特點:(1)各個具體的建造者相互獨立,有利於系統的擴展。(2)客戶端不必知道產品內部的組成細節,便於控制細節風險。
主要角色 Product,AbstractBuilder,Builder,Director
C++實現
Product.h
#pragma once
#include<string>
using namespace std;
class Product {
public:
Product();
~Product();
void setPartA(string param);
void setPartB(string param);
void setPartC(string param);
void show();
private:
string partA;
string partB;
string partC;
};
Product.cpp
#include"Product.h"
#include<iostream>
using namespace std;
Product::Product() {
}
Product::~Product() {
}
void Product::setPartA(string param) {
this->partA = param;
}
void Product::setPartB(string param) {
this->partB = param;
}
void Product::setPartC(string param) {
this->partC = param;
}
void Product::show() {
cout << "partA:" << partA << " partB:" << partB << " partC:" << partC << endl;
}
Builder.h
#pragma once
#include"Product.h"
class AbstractBuilder {
public:
AbstractBuilder();
virtual ~AbstractBuilder();
virtual void buildPartA(string param) = 0;
virtual void buildPartB(string param) = 0;
virtual void buildPartC(string param) = 0;
virtual void PrepareProduct() = 0;
virtual Product* createProduct() = 0;
};
class Builder :public AbstractBuilder {
public:
Builder();
~Builder();
void buildPartA(string param);
void buildPartB(string param);
void buildPartC(string param);
void PrepareProduct();
Product* createProduct();
private:
Product* curProduct;
};
Builder.cpp
#include"Builder.h"
#include<iostream>
using namespace std;
AbstractBuilder::AbstractBuilder() {
}
AbstractBuilder::~AbstractBuilder() {
}
Builder::Builder() {
}
Builder::~Builder() {
}
void Builder::PrepareProduct() {
cout << "創建一個產品骨架" << endl;
curProduct = new Product();
}
void Builder::buildPartA(string param) {
cout << "正在構造產品A部分" << endl;
curProduct->setPartA(param);
}
void Builder::buildPartB(string param) {
cout << "正在構建產品B部分" << endl;
curProduct->setPartB(param);
}
void Builder::buildPartC(string param) {
cout << "正在構建產品C部分" << endl;
curProduct->setPartC(param);
}
Product* Builder::createProduct() {
return curProduct;
}
Director.h
#pragma once
#include"Builder.h"
class Director {
public:
Director(AbstractBuilder* builder);
~Director();
void construct();
private:
AbstractBuilder* curBuilder;
};
Director.cpp
#include"Director.h"
Director::Director(AbstractBuilder* builder) {
this->curBuilder = builder;
}
Director::~Director() {
}
void Director::construct() {
if (curBuilder == nullptr) return;
curBuilder->PrepareProduct();
curBuilder->buildPartA("A");
curBuilder->buildPartB("B");
curBuilder->buildPartC("C");
}
main.cpp
#include"Director.h"
int main(void) {
AbstractBuilder* builder = new Builder();
Director* director = new Director(builder);
director->construct();
Product* product = builder->createProduct();
product->show();
return 0;
}