几种常见设计模式的实现

单例设计模式的实现：（懒汉式，线程安全）

#include <iostream>
#include <mutex>

using namespace std;

class Singleton{
public:
	static Singleton* getInstance();
	void SingletonOperation();
private:
	static Singleton* singleton;
	static mutex s_mutex;
	Singleton(){}
	~Singleton();
};

Singleton* Singleton::singleton = NULL;

Singleton* Singleton::getInstance() {
	if (singleton == NULL) {
		lock_guard<mutex> lock(s_mutex);
		if (singleton == NULL) {
			singleton = new Singleton();
			cout << "new a singleton" << endl;
		}
	}
	return singleton;
}

Singleton::~Singleton() {
	if (singleton != NULL)
	{
		delete singleton;
		singleton = nullptr;
	}
}

void  Singleton::SingletonOperation() {
	cout << "singleton operation" << endl;
}

int main() {
	Singleton* single = Singleton::getInstance();
	single->SingletonOperation();
}

 工厂设计模式实现

#include <iostream>

using namespace std;

class Product {
public:
	Product(){}
	~Product(){}
	virtual void use() = 0;
};

class CreateProductA : public Product
{
public:
	CreateProductA(){}
	~CreateProductA(){}
	virtual void use() {
		cout << "create product A" << endl;
	}
};

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

class CreateFactory : public Factory
{
public:
	CreateFactory(){}
	~CreateFactory(){}
	virtual Product* CreateProduct() {
		return new CreateProductA();
	}
};

int main() {
	//当有不同的产品加入时， 创建产品的实例， 只需要创建一个新产品的Factory类， 不需要对上一个产品的类进行修改
	Factory* factory = new CreateFactory();
	Product* productA = factory->CreateProduct();
	productA->use();
	delete productA;
	delete factory;
}

 抽象工厂的设计实现：

#include <iostream>

using namespace std;

class AbstractProductA {
public:
	AbstractProductA(){}
	~AbstractProductA(){}
	virtual void set() = 0;
};

class AbstractProductB {
public:
	AbstractProductB(){}
	~AbstractProductB(){}
	virtual void use() = 0;
};

class ProductA1 : public AbstractProductA
{
public:
	ProductA1(){}
	~ProductA1(){}
	virtual void set() {
		cout << "product  A  1" << endl;
	}
};

class ProductA2 : public AbstractProductA
{
public:
	ProductA2(){}
	~ProductA2(){}
	virtual void set() {
		cout << "product A 2 " << endl;
	}
};

class ProductB1 : public AbstractProductB
{
public:
	ProductB1(){}
	~ProductB1(){}
	virtual void use() {
		cout << "product B 1" << endl;
	}
};

class ProductB2 : public AbstractProductB
{
public:
	ProductB2(){}
	~ProductB2(){}
	virtual void use() {
		cout << "product B 2" << endl;
	}
};

class AbstractFactory {
public:
	AbstractFactory(){}
	~AbstractFactory(){}
	virtual AbstractProductA* createProductA() = 0;
	virtual AbstractProductB* createProductB() = 0;
};

class AbstractFactory1 : public AbstractFactory
{
public:
	AbstractFactory1(){}
	~AbstractFactory1(){}
	virtual AbstractProductA* createProductA() {
		return new ProductA1();
	}
	virtual AbstractProductB* createProductB() {
		return new ProductB1();
	}
};

class AbstractFactory2 : public AbstractFactory
{
public:
	AbstractFactory2(){}
	~AbstractFactory2(){}
	virtual AbstractProductA* createProductA() {
		return new ProductA2();
	}
	virtual AbstractProductB* createProductB() {
		return new ProductB2();
	}
};

int main() {
	AbstractFactory* factory1 = new AbstractFactory1();
	AbstractProductA* productA1 = factory1->createProductA();
	productA1->set();
	AbstractProductB* productB1 = factory1->createProductB();
	productB1->use();
	AbstractFactory* factory2 = new AbstractFactory2();
	AbstractProductA* productA2 = factory2->createProductA();
	productA2->set();
	AbstractProductB* productB2 = factory2->createProductB();
	productB2->use();
	delete productB2;
	delete productA2;
	delete factory2;
	delete productB1;
	delete productA1;
	delete factory1;
}

 适配器模式实现：

Adaptee.h

#pragma once 
#ifndef _ADAPTEE_H
#define _ADAPTEE_H

#include <iostream>

class Adaptee
{
public:
	Adaptee(){}
	~Adaptee(){}
	void Request();
};

#endif

Adaptee.cpp

#include "Adaptee.h"

void Adaptee::Request()
{
	std::cout << "response for Adapter" << std::endl;
}

Adapter.h

#pragma once 
#ifndef _ADAPTER_H
#define _ADAPTER_H

#include "Adapter.h"

class Adaptee;

class Adapter
{
public:
	Adapter(Adaptee* adapter);
	~Adapter(){}
	void SpecificRequest();
private:
	Adaptee* m_adaptee;
};

#endif

Adapter.cpp

#include "Adapter.h"
#include "Adaptee.h"

Adapter::Adapter(Adaptee* adapter)
{
	m_adaptee = adapter;
}

void Adapter::SpecificRequest()
{
	m_adaptee->Request();
}

main.cpp

#include "Adaptee.h"
#include "Adapter.h"

int main()
{
	Adaptee* adaptee = new Adaptee();
	Adapter* adapter = new Adapter(adaptee);
	adapter->SpecificRequest();
	delete adaptee;
	delete adapter;
}