设计模式

设计模式

• 单例模式是什么？
• 单例模式的代码实现？
• 工厂模式是什么？
• 工厂模式的代码实现？
• 装饰器模式是什么？
• 装饰器模式的代码实现？
• 观察者模式是什么？
• 观察者模式的代码实现？

单例模式是什么？

定义：保证一个类只有一个实例，并提供一个访问该实例的全局节点，该实例对于程序模块来说是全局共享的。

条件：单例模式需要满足：类不能够被复制，类不能够被外部构造。所以类的构造函数、拷贝构造函数和赋值函数都是对外不可见的。

实现 ：单例模式的实现分为懒汉模式 和饿汉模式 两种。其中懒汉模式 具有延迟加载的特点，只有到用到单例类的时候才会去实例化。，而饿汉模式 则是在类定义的时候就进行初始化，因为初始化在程序执行之前，所有没有多线程问题。

单例模式的代码实现？

懒汉模式：静态指针（线程安全）

template<typename T>
class Single {
public:
	static T& getInstance() {
		// 如果值为空，则创建实例
		if (!value_) value_ = new T();
		// 不为空，则获取实例
		return *value_;
	}

private:
	Single();				// 不可见
	~Single();				// 不可见
	static T* value_;		// 指向其他类的指针 (T)
	// 定义清除类
	static SingleClean {
	public:
		~SingleClean() {
			// 如果单例中成员不为空，则释放 
			if (Single::value_) {
				delete Single::value_;
			}
		}
	};
	static SingleClean singleClean;
	// 声明一个内部类，用于程序结束时释放单例类
};

// 初始化，用到时才初始化
template<typename T>
T* Single<T>::value_ = nullptr;

饿汉模式：静态对象（线程安全）

class Single {
public:
	static Single& GetInstance() {
		return m_single;
	}
private:
	Single();
	~Single();
	Single& operator=(const Single&);
	static Single m_single;
};

// 定义时初始化
Single Single::m_single{};

工厂模式是什么？

定义：提供一个创建对象的接口，让子类去决定具体实例化哪个类。同时将创建对象过程统一交给工厂进行管理。

实现 ：工厂模式属于创建型的模式，大致可以分为简单工厂模式 、工厂方法模式 和抽象工厂模式。在简单工厂模式中，有 A，B 等多种商品，统一由一个工厂进行生产。在工厂方法模式中，有多个工厂，其中工厂 A 负责生产商品 A，工厂 B 负责生产商品 B。在抽象工厂模式中，商品被进行了抽象，比如有大品牌的商品 A，B 和小品牌的商品 A，B，那么工厂 A 可以实现生产不同品牌的商品 A，工厂 B 可以实现生产不同品牌的商品 B。

工厂模式的代码实现？

简单工厂模式：

enum CTYPE {COREA, COREB};
// 核心
class Core {
public:
	virtual void show() = 0;		// 纯虚函数
};
// 核心 A
class CoreA : public Core {
public:
	void show() { cout << "show CoreA" << endl; }
};
// 核心 B
class CoreB : public Core {
public:
	void show() { cout << "show CoreB" << endl; }
};
// 工厂生产核心，内部判断生产类型
class Factory {
public:
	Core* CreateCore(enum CTYPE ctype) {
		if (ctype == COREA) {
			return new CoreA();
		} else if (ctype == COREB) {
			return new CoreB();
		} else {
			return nullptr;
		}
	}
};

工厂方法模式：

// 核心父类
class Core {
public:
	virtual void show() = 0;
};
// 核心 A
class CoreA : public Core {
public:
	void show() { cout << "show CoreA" << endl; }
};
// 核心 B
class CoreB : public Core {
public:
	void show() { cout << "show CoreB" << endl; }
};
// 工厂父类
class Factory {
public:
	virtual Core* CreateCore() = 0;
};
class FactoryA : public Factory {
public:
	CoreA* CreateCore() { return new CoreA; }
};
class FactoryB : public Factory {
public:
	CoreB* CreateCore() { return new CoreB; }
};

抽象工厂模式：

// 核心父类
class Core {
public:
	virtual void show() = 0;
};
// 核心 A
class CoreA : public Core {
public:
	void show() { cout << "show CoreA" << endl; }
};
// 核心 B
class CoreB : public Core {
public:
	void show() { cout << "show CoreB" << endl; }
};
// 多核心父类
class MultiCore {
public:
	virtual void show() = 0;
};
// 多核心 A
class MultiCoreA : public MultiCore {
public:
	void show() { cout << "show MultiCoreA" << endl; }
};
// 多核心 B
class MultiCoreB : public MultiCore {
public:
	void show() { cout << "show MultiCoreB" << endl; }
};
// 工厂父类
class Factory {
public:
	virtual Core* CreateCore() = 0;
	virtual MultiCore* CreateMultiCore() = 0;
};
class FactoryA : public Factory {
public:
	CoreA* CreateCore() { return new CoreA; }
	CoreA* CreateMultiCore() { return new MultiCoreA; }
};
class FactoryB : public Factory {
public:
	CoreB* CreateCore() { return new CoreB; }
	MultiCoreB* CreateMultiCore() { return new MultiCoreB; }
};

装饰器模式是什么？

定义：不改变现有对象的结构的情况下，动态的给现有对象添加一些额外的功能。

实现：装饰器模式属于对象结构性设计模式，装饰器主要包含抽象组件，具体组件，抽象装饰和具体装饰。比如我现在定义了一个学生类，表示抽象组件，那么大学生和小学生就可以代表具体组件。穿衣服可以定义为抽象修饰，而穿具体的短袖外套则是具体修饰。

装饰器模式的代码实现？

给人穿上不同的衣服：

// 抽象组件
class Person {
protected:
	string m_name;
public:
	Person() {}
	~Person() {}
	Person(string name) : m_name(name) {}
	virtual void show() = 0;
};

// 具体组件
class Student : public Person {
public:
	Student(string name) : Person(name) {}
	void show() override {
		cout << "学生: " << m_name << endl;
	}
};

// 抽象装饰器
class Cloth : public Person {
protected:
	Person* m_component = nullptr;	// 没穿衣服的人
public:
	Cloth() {}
	~Cloth() {}
	// 打扮
	void Decorator(Person* component) {
		this->m_component = component;
	}
	// 显示
	void show() {
		if (m_component != nullptr) {
			m_component->show();
		} else {
			cout << "没穿衣服" << endl;
		}
	}
};

// 具体装饰器
class Tshirts : public Cloth {
public:
	Tshirts() {}
	void show() {
		cout << "穿T恤" << endl;
		Cloth::show();
	}
};

观察者模式是什么？

定义：是指多个对象之间存在着一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会被通知并更新。

实现：观察者模式属于是行为型的模式，它主要由抽象目标，具体目标，抽象观察者和具体观察者组成。比如说像粉丝订阅博客，当博主发表新文章的时候，那么博主的状态就发生了改变，那么订阅者就会收到相应的通知，进行阅读和点赞。

观察者模式的代码实现？

// 抽象目标
class Blog {
public:
	Blog() {}
	~Blog() {}
	// 添加观察者
	void attach(Observer* observer) { m_observers.push_back(observer); }
	// 移除观察者
	void remove(Observer* observer) { m_observers.remove(observer); }
	// 通知观察者
	void notify() {
		for (auto it = m_observers.begin(); it != m_observers.end(); ++it) {
			(*it)->update();
		}
	}
private:
	list<Observer*> m_observers;		// 观察者链表
protect:
	string m_status;					// 观察者状态
};

// 具体目标
class BlogCSDN : public Blog {
private:
	string m_name;			// 博主名称
public:
	BlogCSDN(string name) : m_name(name) {}
	~Blog() {}
	void SetStatus(string s) { m_status = "CSDN" + m_name + s; }
	string GetStatus() { return m_status; }
};

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

// 具体观察者
class ObserverBlog : public Observer {
private:
	string m_name;		// 观察者名称
	Blog* m_blog;		// 订阅的博客
public:
	ObserverBlog(string name, Blog* blog) : m_name(name), m_blog(blog) {}
	~ObserverBlog() {}
	void update() {
		string status = m_blog->getStatus();
		cout << m_name << "-------" << status << endl;
	}
};