42.设计模式1

Posted 2022-11-25 干锅土鸡

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

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对象，不用了解对象创建的详细过程。提供创建对象实例的接口函数不闭合，不能对修改闭合

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

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