C++常用设计模式详解

1. 面向对象的设计原则：

高内聚：设计封装模块的时候功能单一，针对性强
低耦合：每个模块之间的交互量少

2. 深入理解面向对象

封装：隐藏颞部实现
继承：复用先有代码
多态：改写对象行为

3. 单例模式：

涉及到一个单一的类，该类负责创建自己的对象，一个类只有一个对象。
单例模式有两种常见的方式，饿汉模式和懒汉模式：
（1）、饿汉模式就是在使用之前先实例化要使用的单例对象
（2）、懒汉模式就是在使用的时候再实例化要使用的单例对象，有线程安全的问题，但多个线程同时检测到没有实例化对象的时候，就会同时创建对象

饿汉模式
class Single{
public:
	//用户创建对象的唯一接口
	//使用静态函数是因为在没有实例化对象的时候可以直接调用函数生成对象
	static Single& createObject(){
		static Single obj;
		return obj;
	}	
private:
	Single(){}
	//禁止用户通过拷贝构造函数创建对象
	Single(Single const &);
};

class Singleton
{
public:
	static Singleton* GetInstance() {
		// 注意这里一定要使用Double-Check的方式加锁，才能保证效率和线程安全
		if (nullptr == m_pInstance) {
			m_mtx.lock();
			if (nullptr == m_pInstance) {
				m_pInstance = new Singleton();
			}
			m_mtx.unlock();
		}
		return m_pInstance;
	}
	// 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象
	static CGarbo Garbo;
private:
	// 构造函数私有
	Singleton(){};
	// 防拷贝
	Singleton(Singleton const&);
	Singleton& operator=(Singleton const&);
	static Singleton* m_pInstance; // 单例对象指针
	static mutex m_mtx; //互斥锁
};
Singleton* Singleton::m_pInstance = nullptr;
Singleton::CGarbo Garbo;
mutex Singleton::m_mtx;

4.工厂模式

1.简单工厂模式：由工厂决定生产哪一种产品，选择什么样的工厂就生产什么样的产品（一类商品，一个工厂）
2.工厂方法模式：将工厂和产品都写成一个抽象类，方便拓展（一类商品，一类工厂）
3.抽象工厂模式：好比一个工厂只生成某一厂家的产品，其他工厂生产别的厂家的，也就是说每个工厂生产的产品之间是有联系的

简单工厂模式：不利于扩展
class Product
{
public:
	virtual void use(){};
};
class ConcreteProductA :public Product
{
public:
	void use()
	{
		cout << "使用A" << endl;
	};
};
class ConcreteProductB:public Product
{
public:
	void use()
	{
		cout << "使用B" << endl;
	};
};
class Factory
{
public:
	Product* Factory::createProduct(string proname){
		if ("A" == proname)
		{
			return new ConcreteProductA();
		}
		else if ("B" == proname)
		{
			return new ConcreteProductB();
		}
		return  NULL;
	}

工厂方法模式：如果产品不是product就没办法扩展
class Product
{
public:
	virtual void Show() = 0;
};
 
class ProductA : public Product
{
public:
	void Show()
	{
		cout << "I'm ProductA" << endl;
	}
};
 
class ProductB : public Product
{
public:
	void Show()
	{
		cout << "I'm ProductB" << endl;
	}
};
 
class Factory
{
public:
	virtual Product *CreateProduct() = 0;
};
 
class FactoryA : public Factory
{
public:
	Product *CreateProduct()
	{
		return new ProductA();
	}
};
 
class FactoryB : public Factory
{
public:
	Product *CreateProduct()
	{
		return new ProductB();
	}
};

抽象工厂模式：
class product1  
{  
public:  
    virtual void show() = 0;  
};  
  
//定义具体类  
class product_A1 :public product1  
{  
public:  
    void show(){ cout << "product A1" << endl; }  
};  
  
class product_B1 :public product1  
{  
public:  
    void show(){ cout << "product B1" << endl; }  
};  
  
//定义抽象类  
class product2  
{  
public:  
    virtual void show() = 0;  
};  
  
//定义具体类  
class product_A2 :public product2  
{  
public:  
    void show(){ cout << "product A2" << endl; }  
};  
  
class product_B2 :public product2  
{  
public:  
    void show(){ cout << "product B2" << endl; }  
};  
  
  
class Factory
{  
public:  
    virtual product1 *creat1() = 0;  
    virtual product2 *creat2() = 0;  
};  
  
class Factory1 : public Factory 
{  
public:  
    product1 *creata(){ return new product_A1(); }  
    product2 *creatb(){ return new product_B1(); }  
};  
  
class Factory2 : public Factory  
{  
public:  
    product1 *creata(){ return new product_A2(); }  
    product2 *creatb(){ return new product_B2(); }  
};