创建型设计模式（Creational Design Patterns）-5种

#include <iostream>
#include <string>
using namespace std;

/*
* 简单工厂模式
*/

// 抽象产品
class AbstractProduct
{
public:
	virtual void info() = 0; // 声明纯虚函数
	virtual ~AbstractProduct() { ; }
};

// 具体产品 A
class ProductA :public AbstractProduct
{
public:
	void info()
	{
		cout << "产品的信息：A" << endl;
	}
    virtual ~ProductA() { ; }
};

// 具体产品 B
class ProductB :public AbstractProduct
{
public:
	void info()
	{
		cout << "产品的信息：B" << endl;
	}
    virtual ~ProductB() { ; }
};

// 简单工厂
class SimpleFactory
{
public:
	static AbstractProduct* CreateProduct(char type)
	{
		AbstractProduct* aProduct = nullptr;
		switch (type)
		{
		case 'A':
			aProduct = new ProductA();
			break;
		case 'B':
			aProduct = new ProductB();
			break;
		default:
			cout << "没有" << type << "类型产品" << endl;
		}
		return aProduct;
	}
};

int main()
{
	// 产品A
	AbstractProduct* aProductA = SimpleFactory::CreateProduct('A');
	if (aProductA)
	{
		aProductA->info();
	}
	// 产品B
	AbstractProduct* aProductB = SimpleFactory::CreateProduct('B');
	if (aProductB)
	{
		aProductB->info();
	}
}

#include <iostream>
#include <string>
using namespace std;

/*
* 工厂方法模式
*/

// 产品接口
class IProduct
{
public:
	virtual void info() = 0; // 声明纯虚函数
	virtual ~IProduct() { ; }
};

// 具体产品 A
class ProductA :public IProduct
{
public:
	void info()
	{
		cout << "产品的信息：A" << endl;
	}
	~ProductA() { ; }
};

// 具体产品 B
class ProductB :public IProduct
{
public:
	void info()
	{
		cout << "产品的信息：B" << endl;
	}
	~ProductB() { ; }
};

// 工厂
class IFactory
{
public:
	virtual IProduct* CreateProduct() = 0;
	virtual ~IFactory() { ; }
};

// 工厂A
class FactoryA :public IFactory
{
public:
	IProduct* CreateProduct()
	{
		return new ProductA();
	};
	~FactoryA() { ; }
};

// 工厂B
class FactoryB :public IFactory
{
public:
	IProduct* CreateProduct()
	{
		return new ProductB();
	};
	~FactoryB() { ; }
};

int main()
{
	// 产品A
	IFactory* factoryA = new FactoryA();
	IProduct* productA = factoryA->CreateProduct();
	productA->info();
	// 产品B
	IFactory* factoryB = new FactoryB();
	IProduct* productB = factoryB->CreateProduct();
	productB->info();

	delete factoryA;
	delete factoryB;
	delete productA;
	delete productB;
}

#include <iostream>
#include <string>
using namespace std;

/*
* 抽象工厂模式
*/

// 产品A接口
class IProductA
{
public:
	virtual void info() = 0; // 声明纯虚函数
	virtual ~IProductA() { ; }
};

// 具体产品 A1
class ProductA1 :public IProductA
{
public:
	void info()
	{
		cout << "产品的信息：A1" << endl;
	}
	~ProductA1() { ; }
};

// 具体产品 A2
class ProductA2 :public IProductA
{
public:
	void info()
	{
		cout << "产品的信息：A2" << endl;
	}
	~ProductA2() { ; }
};

// 产品B接口
class IProductB
{
public:
	virtual void info() = 0; // 声明纯虚函数
	virtual ~IProductB() { ; }
};

// 具体产品 B1
class ProductB1 :public IProductB
{
public:
	void info()
	{
		cout << "产品的信息：B1" << endl;
	}
	~ProductB1() { ; }
};

// 具体产品 B2
class ProductB2 :public IProductB
{
public:
	void info()
	{
		cout << "产品的信息：B2" << endl;
	}
	~ProductB2() { ; }
};

// 工厂
class IFactory
{
public:
	virtual IProductA* CreateProductA() = 0;
	virtual IProductB* CreateProductB() = 0;
	virtual ~IFactory() { ; }
};

// 工厂1
class Factory1 :public IFactory
{
public:
	IProductA* CreateProductA()
	{
		return new ProductA1();
	};
	IProductB* CreateProductB()
	{
		return new ProductB1();
	};
	~Factory1() { ; }
};

// 工厂2
class Factory2 :public IFactory
{
public:
	IProductA* CreateProductA()
	{
		return new ProductA2();
	};
	IProductB* CreateProductB()
	{
		return new ProductB2();
	};
	~Factory2() { ; }
};

int main()
{
	// 产品A
	IFactory* factory1 = new Factory1();
	IProductA* productA1 = factory1->CreateProductA();
	IProductB* productB1 = factory1->CreateProductB();
	productA1->info();
	productB1->info();
	// 产品B
	IFactory* factory2 = new Factory2();
	IProductA* productA2 = factory2->CreateProductA();
	IProductB* productB2 = factory2->CreateProductB();
	productA2->info();
	productB2->info();
}

#include <iostream>
#include <string>
#include <list>
#include<vector>
using namespace std;

/*
* 建造者（生成器）模式
*/

// 产品
class CProduct
{
public:
	vector<string> parts;
public:
	void Add(string part)
	{
		parts.push_back(part);
	}
	void Show()
	{
		cout << "产品的组成：";
		for (int i = 0; i < parts.size(); i++)
		{
			cout << parts[i] << " ";
		}
		cout << endl;
	}
	~CProduct() { ; }
};

// 抽象生成器类
class ABuilder
{
public:
	virtual void BuildPart() = 0;
	virtual CProduct* GetResult() = 0;
	virtual ~ABuilder() { ; }
};

// 套餐1
class CBuilder1 :public ABuilder
{
public:
	CProduct* product;
public:
	void BuildPart()
	{
		product = new CProduct();
		product->Add("A");
		product->Add("B");
		product->Add("C");
	};
	CProduct* GetResult()
	{
		return product;
	};
	~CBuilder1() { ; }
};

// 套餐2
class CBuilder2 :public ABuilder
{
public:
	CProduct* product;
public:
	void BuildPart()
	{
		product = new CProduct();
		product->Add("D");
		product->Add("E");
		product->Add("F");
	};
	CProduct* GetResult()
	{
		return product;
	};
	~CBuilder2() { ; }
};

// 导演
class CDirector
{
public:
	void Construct(ABuilder* aBuilder)
	{
		aBuilder->BuildPart();
	};
	~CDirector() { ; }
};

int main()
{
	CDirector* director = new CDirector();
	// 套餐1
	ABuilder* builder1 = new CBuilder1();
	director->Construct(builder1);
	CProduct* product1 = builder1->GetResult();
	product1->Show();
	// 套餐2
	ABuilder* builder2 = new CBuilder2();
	director->Construct(builder2);
	CProduct* product2 = builder2->GetResult();
	product2->Show();
}

#include <iostream>
#include <string>
using namespace std;

/*
* 原型模式
*/

// 抽象原型类
class IPrototype
{
public:
	int* value = 0;
public:
	virtual IPrototype* Clone() = 0;
	~IPrototype() { ; }
};

// 具体原型类(深拷贝)
class PrototypeD :public IPrototype
{
public:
	PrototypeD() { value = nullptr; }
	PrototypeD(int v) { value = new int(v); }
	PrototypeD(const PrototypeD& prototype) // 深拷贝构造函数
	{
		value = new int(*prototype.value);
	}
	// 深拷贝赋值操作符
	PrototypeD& operator=(const PrototypeD& prototype)
	{
		if (this == &prototype)
		{
			return *this;
		}
		delete value;
		value = new int(*prototype.value);
		return *this;
	}
	PrototypeD* Clone()
	{
		return new PrototypeD(*this);
	}
	int GetValue() const
	{
		return *value;
	}
	~PrototypeD() { ; }
};

// 具体原型类(浅拷贝)
class PrototypeS :public IPrototype
{
public:
	PrototypeS() { value = nullptr; }
	PrototypeS(int v) { value = new int(v); }
	PrototypeS(const PrototypeS& prototype) // 浅拷贝构造函数
	{
		value = prototype.value;
	}
	// 浅拷贝赋值操作符
	PrototypeS& operator=(const PrototypeS& prototype)
	{
		if (this == &prototype)
		{
			return *this;
		}
		value = prototype.value;
		return *this;
	}
	PrototypeS* Clone()
	{
		return new PrototypeS(*this);
	}
	int GetValue() const
	{
		return *value;
	}
	~PrototypeS() { ; }
};

int main()
{
	// 深拷贝
	cout << "深拷贝:" << endl;
	PrototypeD prototypeD(10);
	PrototypeD prototypeD1 = *prototypeD.Clone();
	*prototypeD.value = 30; // 修改原型的值
	cout << "prtotypeD 的 value = " << *prototypeD.value << endl;
	cout << "prtotypeD1 的 value = " << *prototypeD1.value << endl;

	// 浅拷贝
	cout << "浅拷贝:" << endl;
	PrototypeS prototypeS(100);
	PrototypeS prototypeS1 = *prototypeS.Clone();
	*prototypeS.value = 200; // 修改原型的值
	cout << "prtotypeS 的 value = " << *prototypeS.value << endl;
	cout << "prtotypeS1 的 value = " << *prototypeS1.value << endl;
}

#include <iostream>
#include <string>
using namespace std;

/*
* 单例模式
*/

// 懒汉版（Lazy Singleton）：单例实例在第一次被使用时才进行初始化，这叫做延迟初始化。
class LazySingleton
{
private:
	int value = 0;
	static LazySingleton* instance;
private:
	LazySingleton() { ; }
	~LazySingleton() { ; }
	LazySingleton(const LazySingleton&) = delete;
	LazySingleton& operator=(const LazySingleton&) = delete;
public:
	static LazySingleton* getInstance()
	{
		if (instance == NULL)
			instance = new LazySingleton();
		return instance;
	}
	int GetValue()
	{
		return value;
	}
	void SetValue(int v)
	{
		value = v;
	}
};

LazySingleton* LazySingleton::instance = NULL;

// 饿汉版（Eager Singleton）:指单例实例在程序运行时被立即执行初始化
class EagerSingleton
{
public:
	static EagerSingleton* instance;
private:
	int value = 0;
private:
	EagerSingleton() { ; }
	~EagerSingleton() { ; }
	EagerSingleton(const EagerSingleton&) = delete;
	EagerSingleton& operator=(const EagerSingleton&) = delete;
public:
	int GetValue()
	{
		return value;
	}
	void SetValue(int v)
	{
		value = v;
	}
};

EagerSingleton* EagerSingleton::instance = new EagerSingleton;

int main()
{
	// 懒汉版
	cout << "懒汉版（Lazy Singleton）" << endl;
	LazySingleton* singleton1 = LazySingleton::getInstance();
	LazySingleton* singleton2 = LazySingleton::getInstance();
	cout << "singleton1 的 value = " << singleton1->GetValue() << endl;
	cout << "singleton2 的 value = " << singleton2->GetValue() << endl;
	singleton1->SetValue(10);
	cout << "singleton1 的 value = " << singleton1->GetValue() << endl;
	cout << "singleton2 的 value = " << singleton2->GetValue() << endl;

	// 饿汉版
	cout << "饿汉版（Eager Singleton）" << endl;
	EagerSingleton* singleton3 = EagerSingleton::instance;
	EagerSingleton* singleton4 = EagerSingleton::instance;
	cout << "singleton3 的 value = " << singleton3->GetValue() << endl;
	cout << "singleton4 的 value = " << singleton4->GetValue() << endl;
	singleton3->SetValue(10);
	cout << "singleton3 的 value = " << singleton3->GetValue() << endl;
	cout << "singleton4 的 value = " << singleton4->GetValue() << endl;
}