42.设计模式1

饿汉单例模式：（是线程安全的）
一个类不管创建多少次对象，永远只能得到该类型一个对象的实例！

class Singleton
{
public:
	static Singleton* getInstance()//获取类的唯一实例对象接口方法
	{
		return &instance;
	}
private:
	static Singleton instance;//定义一个唯一的类的实例对象
	Singleton()
	{
		
	}
	Singleton(const Singleton&)=delete;
	Singleton& operator=(const Singleton&)=delete;
};
Single Single::instance;

int mian()
{
	Singleton* p1 = Singleton::getInstance();
	Singleton* p2 = Singleton::getInstance();
	Singleton* p3 = Singleton::getInstance();//以上三个地址一样！
	return 0;
}

懒汉单例模式：
唯一的实例对象，直到第一次获取它的时候，才产生对象！！！
是否线程安全？是不是可重入函数？
不是线程安全的：instance==nullptr可能会进去多次！因为三个步骤到第二步时间片到了就完了！

class Singleton
{
public:
	static Singleton* getInstance()//获取类的唯一实例对象接口方法
	{
		if(instance == nullptr)
		{
			instance = new Singleton();//1.开辟内存2.构造函数3.赋值
		}
		return instance;
	}
private:
	static Singleton* instance;//定义一个唯一的类的实例对象
	Singleton()
	{
		
	}
	Singleton(const Singleton&)=delete;
	Singleton& operator=(const Singleton&)=delete;
};
Singleton* Singleton::instance = nullptr;

int mian()
{
	Singleton* p1 = Singleton::getInstance();
	Singleton* p2 = Singleton::getInstance();
	Singleton* p3 = Singleton::getInstance();//以上三个地址一样！
	return 0;
}

改进：

static Singleton* getInstance()//获取类的唯一实例对象接口方法
{
	if(instance == nullptr)
	{
		lock_guard<std::mutex> guard(mtx);
		if(instance == nullptr)//锁+二重判断！
		{
			instance = new Singleton();//1.开辟内存2.构造函数3.赋值
		}
	}
	return instance;
}

经过改造才是一个线程安全的懒汉式的单例模式！
也可以这样写：

简单工厂、工厂方法、抽象工厂：
工厂模式：主要是封装了对象的创建！

简单工厂：

class Car
{
public:
	Car(string name):_name(name){}
	virtual void show() = 0;
protected:
	string _name;
};
class Bmw:public Car
{
public:
	Bmw(string name):Car(name){}
	void show()
	{
		cout << "获取Bmw汽车" << endl;
	}
};
class Audi:public Car
{
public:
	Audi(string name):Car(name){}
	void show()
	{
		cout << "获取Audi汽车" << endl;
	}
};

enum CarType
{
	BMW,AUDI
};
class SimpleFactory()
{
public:
	Car* createCar(CarType ct)
	{
		switch(ct)
		{
		case BMW:
			return  new Bmw("X1");
		case AUDI:
			return new Audi("A6");
		default:
			cerr << "参数错误！" << ct << endl;
			break;
		}
		return nullptr;
	}
};
int main()
{
	//SimpleFactory* factory = new SimpleFactory();
	unique_ptr<SimpleFactory> factory(new SimpleFactory());
	//Car* p1 = factory->createCar(Bmw);
	//Car* p2 = factory->createCar(AUDI);
	unique_ptr< Car> p1(factory->createCar(Bmw));
	unique_ptr< Car> p2(factory->createCar(AUDI));
	p1->show();
	p2->show();
	return 0;
}

工厂方法：


抽象工厂：

// 系列产品2
class Light
{
public:
	virtual void show() = 0;
};
class BmwLight : public Light
{
public:
	void show() { cout << "BMW light!" << endl; }
};
class AudiLight : public Light
{
public:
	void show() { cout << "Audi light!" << endl; }
};

// 工厂方法 => 抽象工厂(对有一组关联关系的产品簇提供产品对象的统一创建)
class AbstractFactory
{
public:
	virtual Car* createCar(string name) = 0; // 工厂方法 创建汽车
	virtual Light* createCarLight() = 0; // 工厂方法 创建汽车关联的产品，车灯
};
// 宝马工厂
class BMWFactory : public AbstractFactory
{
public:
	Car* createCar(string name)
	{
		return new Bmw(name);
	}
	Light* createCarLight()
	{
		return new BmwLight();
	}
};
// 奥迪工厂
class AudiFactory : public AbstractFactory
{
public:
	Car* createCar(string name)
	{
		return new Audi(name);
	}
	Light* createCarLight()
	{
		return new AudiLight();
	}
};
int main()
{
	// 现在考虑产品  一类产品（有关联关系的系列产品）
	unique_ptr<AbstractFactory> bmwfty(new BMWFactory());
	unique_ptr<AbstractFactory> audifty(new AudiFactory());
	unique_ptr<Car> p1(bmwfty->createCar("X6"));
	unique_ptr<Car> p2(audifty->createCar("A8"));
	unique_ptr<Light> l1(bmwfty->createCarLight());
	unique_ptr<Light> l2(audifty->createCarLight());

	p1->show();
	l1->show();

	p2->show();
	l2->show();

	return 0;
}

不是一个产品一个工厂，而是一个工厂一系列的产品都做！

简单工厂：把对象创建封装在一个接口函数里面，通过传入不同的标识，返回创建的对象，客户不用自己负责new对象，不用了解对象创建的详细过程。提供创建对象实例的接口函数不闭合，不能对修改闭合

工厂方法：提供了一个纯虚函数（创建产品），定义派生类负责创建对应的产品，在不同的工厂里面创建，能够对现有工厂以及产品的修改关闭。实际上很多产品是有关联关系的，属于一个产品族，不应该放在一个工厂里面创建，这样一是不符合实际的产品对象创建逻辑，二是工厂类太多了。

抽象工厂：
把有关联关系的，属于一个产品族的所有产品创建的接口函数，放在一个抽象工厂里面，派生类应该负责创建该产品族里面所有的产品