常用设计模式C++实现（一）

---

前言

23个设计模式总结整理——创建型模式(5个)

---

一、创建型模式

1.Factory模式

功能

1. 定义创建对象的接口，封装了对象的创建；让子类决定实例化哪一个类；
2. 使得具体化类的工作延迟到了子类中

图示

实现

//Product.h
#ifndef _PRODUCT_H_
#define _PRODUCT_H_

class Product {
public:
	virtual ~Product() = 0;
protected:
	Product(); //屏蔽构造函数
};

class ConcreteProduct:public Product {
public:
	~ConcreteProduct();
	ConcreteProduct();
private:
protected:

};

#endif

//Product.cpp
#include "Product.h"
#include<iostream>
using namespace std;

Product::Product() {

}

Product::~Product() {

}

ConcreteProduct::ConcreteProduct() {
	cout << "ConcreteProduct..." << endl;
}

ConcreteProduct::~ConcreteProduct() {
}

//Factory.h
#ifndef _FACTORY_H_
#define _FACTORY_H_

class Product;

class Factory {
public:
	virtual ~Factory() = 0;
	virtual Product* CreateProduct() = 0;
protected:
	Factory();
private:

};

class ConcreteFactory :public Factory {
public:
	~ConcreteFactory();
	ConcreteFactory();
	Product* CreateProduct();
protected:
private:

};

#endif

//Factory.cpp
#include "Factory.h"
#include "Product.h"
#include<iostream>
using namespace std;

Factory::Factory() {
}

Factory::~Factory() {
}

ConcreteFactory::ConcreteFactory() {
	cout << "ConcreteFactory..." << endl;
}

ConcreteFactory::~ConcreteFactory() {
}

Product* ConcreteFactory::CreateProduct() {
	return new ConcreteProduct();
}

//main.cpp
#include "Factory.h"
#include "Product.h"
#include<iostream>
using namespace std;

int main() {
	Factory* fac = new ConcreteFactory();
	Product* p = fac->CreateProduct();
	return 0;
}

结果

2. AbstractFactory模式

功能

创建一组相关或者相互依赖的对象，如游戏中，在每个关卡，要创建怪物实例，初级就创建初级怪物（有很多种类），中级创建中级怪物等。

图示

实现

//Procduct.h
#ifndef _PRODUCT_H_
#define _PRODUCT__H_

class AbstractProductA {
public:
	virtual ~AbstractProductA();
protected:
	AbstractProductA();
private:
};

class AbstractProductB {
public:
	virtual ~AbstractProductB();
protected:
	AbstractProductB();
private:
};

class ProductA1 :public AbstractProductA {
public:
	ProductA1();
	~ProductA1();
protected:
private:
};

class ProductA2 :public AbstractProductA {
public:
	ProductA2();
	~ProductA2();
protected:
private:
};

class ProductB1 :public AbstractProductB {
public:
	ProductB1();
	~ProductB1();
protected:
private:
};

class ProductB2 :public AbstractProductB {
public:
	ProductB2();
	~ProductB2();
protected:
private:
};

#endif

//Product.cpp
#include "Product.h"
#include<iostream>
using namespace std;

AbstractProductA::AbstractProductA() {
}

AbstractProductA::~AbstractProductA() {
}

AbstractProductB::AbstractProductB() {
}

AbstractProductB::~AbstractProductB() {
}

ProductA1::ProductA1() {
	cout << "ProductA1..." << endl;
}

ProductA1::~ProductA1() {
}

ProductA2::ProductA2() {
	cout << "ProductA2..." << endl;
}

ProductA2::~ProductA2() {
}

ProductB1::ProductB1() {
	cout << "ProductB1..." << endl;
}

ProductB1::~ProductB1() {
}

ProductB2::ProductB2() {
	cout << "ProductB2..." << endl;
}

ProductB2::~ProductB2() {
}

//AbstractFactory.h
#ifndef _ABSTRACTFACTORY_H_
#define _ABSTRACTFACTORY_H_

class AbstractProductA;
class AbstractProductB;

class AbstractFactory {
public:
	virtual ~AbstractFactory();
	virtual AbstractProductA* CreateProductA() = 0;
	virtual AbstractProductB* CreateProductB() = 0;
protected:
	AbstractFactory();
private:
};

class ConcreteFactory1 :public AbstractFactory {
public:
	ConcreteFactory1();
	~ConcreteFactory1();
	AbstractProductA* CreateProductA();
	AbstractProductB* CreateProductB();
protected:
private:
};

class ConcreteFactory2 :public AbstractFactory {
public:
	ConcreteFactory2();
	~ConcreteFactory2();
	AbstractProductA* CreateProductA();
	AbstractProductB* CreateProductB();
protected:
private:
};

#endif

//AbstractFactory.cpp
#include "AbstractFactory.h"
#include "Product.h"
#include<iostream>
using namespace std;

AbstractFactory::AbstractFactory() {
}

AbstractFactory::~AbstractFactory() {
}

ConcreteFactory1::ConcreteFactory1() {
}

ConcreteFactory1::~ConcreteFactory1() {
}

AbstractProductA* ConcreteFactory1::CreateProductA() {
	return new ProductA1();
}

AbstractProductB* ConcreteFactory1::CreateProductB() {
	return new ProductB1();
}

ConcreteFactory2::ConcreteFactory2() {
}

ConcreteFactory2::~ConcreteFactory2() {
}

AbstractProductA* ConcreteFactory2::CreateProductA() {
	return new ProductA2();
}

AbstractProductB* ConcreteFactory2::CreateProductB() {
	return new ProductB2();
}

//main.cpp
#include "AbstractFactory.h"
#include<iostream>
using namespace std;

int main(int argc, char* argv[]) {
	AbstractFactory* cf1 = new ConcreteFactory1();
	cf1->CreateProductA();
	cf1->CreateProductB();

	AbstractFactory* cf2 = new ConcreteFactory2();
	cf2->CreateProductA();
	cf2->CreateProductB();

	return 0;
}

结果

3. Singleton模式

功能

保证只能创建一个对象

图示

实现

//Singleton.h
#ifndef _SINGLKETON_H_
#define _SINGLETON_H_
#include<iostream>
using namespace std;

class Singleton {
public:
	static Singleton* Instance();
protected:
	Singleton();
private:
	static Singleton* _instance;
};

#endif

//Singleton.cpp
#include "Singleton.h"
#include<iostream>
using namespace std;

Singleton* Singleton::_instance = 0;

Singleton::Singleton() {
	cout << "Singleton..." << endl;
}

Singleton* Singleton::Instance() {
	if (_instance == 0) {
		_instance = new Singleton();
	}
	return _instance;
}

//main.cpp
#include"Singleton.h"
#include<iostream>
using namespace std;

int main(int argc, char* argv[]) {
	Singleton* sgn = Singleton::Instance();
	return 0;
}

结果

4. Builder模式

功能

当我们要创建的对象很复杂是（通常由很多其他的对象组合而成），要把复杂对象的创建过程与这个对象的表示分离开来，这样做的好处是，通过一步步地进行复杂对象的构建，由于在每一步的构造过程中可以引入参数，使得经过相同的步骤创建最后得到的对象的展示不一样
例如，大学生活就是一个Builder模式的最好体验：要完成大学教育，一般将大学教育过程分成4个学期进行，因此每一学期可以看做是构建完整大学教育的一个部分教育过程，每个人经过这4年的构建过程得到最后的结果不一样，因为可能在四个阶段的构建中引入了很多的参数。（每个人的机会际遇不完全相同）

图示

实现

//Product.h
#ifndef _PRODUCT_H_
#define _PRODUCT_H_

class Product {
public:
	Product();
	~Product();
	void ProducePart();
protected:
private:
};

class ProductPart {
public:
	ProductPart();
	~ProductPart();
	ProductPart* BuildPart();
protected:
private:
};
#endif

//Product.cpp
#include "Product.h"
#include<iostream>
using namespace std;

Product::Product() {
	ProducePart();
	cout << "return a product" << endl;
}

Product::~Product() {
}

void Product::ProducePart() {
	cout << "build a part of product.." << endl;
}
ProductPart::ProductPart() {
	cout << "build product part" << endl;
}

ProductPart::~ProductPart() {
}

ProductPart* ProductPart::BuildPart() {
	return new ProductPart;
}

//Builder.h
#ifndef _BUILIDER_H_
#define _BUILDER_H_
#include<iostream>
using namespace std;

class Product;

class Builder {
public:
	virtual ~Builder();
	virtual void BuildPartA(const string& buildPara) = 0;
	virtual void BuildPartB(const string& buildPara) = 0;
	virtual void BuildPartC(const string& buildPara) = 0;
	virtual Product* GetProduct() = 0;
protected:
	Builder();
private:
};

class ConcreteBuilder :public Builder {
public:
	ConcreteBuilder();
	~ConcreteBuilder();
	void BuildPartA(const string& buildPara);
	void BuildPartB(const string& buildPara);
	void BuildPartC(const string& buildPara);
	Product* GetProduct();
protected:
private:
};

#endif

//Builder.cpp
#include "Builder.h"
#include "Product.h"
#include<iostream>
using namespace std;

Builder::Builder() {
}

Builder::~Builder() {
}

ConcreteBuilder::ConcreteBuilder() {
}

ConcreteBuilder::~ConcreteBuilder() {
}

void ConcreteBuilder::BuildPartA(const string& buildPara) {
	cout << "Step1:Bild PartA..." << buildPara << endl;
}

void ConcreteBuilder::BuildPartB(const string& buildPara) {
	cout << "Step2:Build PartB..." << endl;
}

void ConcreteBuilder::BuildPartC(const string& buildPara) {
	cout << "Step3:Build PartC..." << endl;
}
 
Product* ConcreteBuilder::GetProduct() {
	BuildPartA("pre-defined");
	BuildPartB("pre-defined");
	BuildPartC("pre-defined");
	return new Product();
}

//Director.h
#ifndef _DIRECTOR_H_
#define _DIRECTOR_H_

class Builder;

class Director {
public:
	Director(Builder* bld);
	~Director();
	void Condtruct();
protected:
private:
	Builder* _bld;
};

#endif

//Director.cpp
#include "Director.h"
#include "Builder.h"

Director::Director(Builder* bld) {
	_bld = bld;
}

Director::~Director() {
}

void Director::Condtruct() {
	_bld->BuildPartA("user-defined");
	_bld->BuildPartB("user-defined");
	_bld->BuildPartC("user-defined");
}

//main.cpp
#include "Builder.h"
#include "Director.h"
#include "Product.h"
#include<iostream>
using namespace std;

int main(int argc, char* argv[]) {
	Director* d = new Director(new ConcreteBuilder());
	d->Condtruct();
	return 0;
}

结果

5.Prototype模式

功能

通过已有对象创建新对象，即复制

图示

实现

//Prototype.h
#ifndef _PROTOTYPE_H_
#define _PROTOTYPE_H_

class Prototype {
public:
	virtual ~Prototype();
	virtual Prototype* Clone() const = 0;
protected:
	Prototype();
private:
};

class ConcretePrototype :public Prototype {
public:
	ConcretePrototype();
	ConcretePrototype(const ConcretePrototype& cp);
	~ConcretePrototype();
	Prototype* Clone() const;
protected:
private:
};

#endif

//Prototype.cpp
#include "Prototype.h"
#include<iostream>
using namespace std;

Prototype::Prototype() {
}

Prototype::~Prototype() {
}

Prototype* Prototype::Clone() const {
	return 0;
}

ConcretePrototype::ConcretePrototype() {
}

ConcretePrototype::~ConcretePrototype() {
}

ConcretePrototype::ConcretePrototype(const ConcretePrototype& cp) {
	cout << "ConcretePrototype copy..." << endl;
}

Prototype* ConcretePrototype::Clone() const {
	return new ConcretePrototype(*this);
}

//main.cpp
#include "Prototype.h"
#include<iostream>
using namespace std;

int main(int argc, char* argv[]) {
	Prototype* p = new ConcretePrototype();
	Prototype* p1 = p->Clone();
	return 0;
}

结果

---

tips

next：结构型模式