设计模式

1. 工厂模式

适合于同种类型的产品。

class Tank {
public:
	virtual string type() = 0;
};

class Tank59 :public Tank {
public:
	string type() override { cout << "tank59::" << endl; return "Tank59"; }
	
};

class Tank96 :public Tank {
public:
	Tank96(string s, int i) :data(s), v(i) {}
	string type() override {
		cout << "tank96::"<< data << " " << to_string(v) << endl; 
		return "Tank96"; 
	}
	string data;
	int v;
};

template<typename T, typename T1>
class Factory
{
public:
	template<typename...Args>
	T* create(Args ...args)
	{
		return new T1(args...);//或者保留参数的坐直或右值性质
		//new T(std::forward<Args>(args)...);
		
	}
	//或者返回智能指针shared_ptr
	template<typename...Args>
	std::shared_ptr<T> create_ptr(Args ...args)
	{
		return make_shared<T>(args...);
		
	}
};
int main(int argc, char** argv)
{
	Factory<Tank, Tank59> *fc = new Factory<Tank, Tank59>;
	Tank* t = fc->create();
	t->type();
	Factory<Tank, Tank96> *f = new Factory<Tank, Tank96>;
	Tank* t1 = f->create<string, int>("s", 13);
	t1->type();
	system("pause");
}

如果在类外定义是这样的
template<typename T, typename T1>
template<typename...Args>
T* Factory<T, T1>::create(Args ...args)
{
	return new T1(args...);
}

2. 单例模式

确保类只有一个实例，并提供一个可以全局的访问的接口。一般用作工具类。单例模式分为懒汉和饿汉两种实现方式。

懒汉：用到实例的时候才实例化，用于不经常访问的情况。

class Singleton
{
private:
	Singleton() {}
	Singleton(const Singleton&) = delete;//单例模式下拷贝构造无意义。
	Singleton& operator=(const Singleton&) = delete;

	static Singleton* p;

public:
	static Singleton* instance();
	static mutex mt;
};

mutex Singleton::mt;
Singleton* Singleton::p = NULL;
Singleton* Singleton::instance()
{
	unique_lock<mutex> lock(mt);
	if (p == NULL)//当两个线程同时判断到p为NULL时会重复创建对象，因此是线程不安全的，所以用mutex来加锁。
		return new Singleton;
	lock.unlock();
	return p;
}

饿汉模式：饿了就饥不择食。单例类定义时就实例化，用于经常访问的情况。本身线程安全。

class Singleton
{
private:
	Singleton() {}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;

	static Singleton* p;

public:
	static Singleton* instance();
};

Singleton* Singleton::instance()
{
	return p;
}

Singleton* Singleton::p = new Singleton;

参考：
https://www.cnblogs.com/chengjundu/p/8473564.html
https://blog.csdn.net/qq_23225317/article/details/79770230

3. 观察者模式

适合于对象的一对多关系，当一个对象发生改变时，其他对象自动更新。

class Observer {//观察者抽象类
public:
	virtual void update() = 0;
};

class Sub :public Observer//具体观察者
{
public:
	void update()
	{
		cout << "Sub::" << endl;
	}
};

class Subject {//目标类
public:
	void attach(shared_ptr<Observer> o)//绑定
	{
		if (l.find(o) == l.end())
			l.insert(o);
		else
			cout << "alreadt attach" << endl;
	}
	void detach(shared_ptr<Observer> o)//解绑
	{
		if (l.find(o) != l.end())
			l.erase(o);
	}
	void notify()//更新观察者
	{
		auto it = l.begin();
		while (it != l.end())
		{
			(*it)->update();
			it++;
		}
	}
private:
	//使用hash结构，便于查询观察对象是否存在
	//使用智能指针，防止观察对象意外删除，导致set中出现野指针，更新操作出错。
	unordered_set<shared_ptr<Observer>> l;
};


shared_ptr<Observer> obj = make_shared<Sub>();
Subject *s = new Subject;
s->attach(obj);

4. 回调

将发生变化的东西同保持不变的东西分隔开。服务类要向用户提供服务，但是随着用户越来越多需求越来越复杂，服务类越来越臃肿，这是服务类把用户不同的地方交给用户实现，自己只实现通用的部分。库开发方调用了用户的函数（回调函数）这就是回调，回体现在库调用用户，用户也调用库。是代码耦合性更低。
如sort()与cmp函数。