Day5 装饰器 设计模式分类 代理模式 迭代器模式 观察者模式 解释器模式

设计模式

设计模式的设计原则

• 单一职责原则： 一个类只干一件事 实现类要单一
• 开放-封闭原则： 软件实体（类、模块、函数等）应该可以扩展 但是不可以修改
  
  设计原则的目的：降低对象之间的耦合 增加程序之间的可复用性 可扩展性 可维护性

设计模式的分类

• 创建型模式： 单例模式 简单工厂模式 工厂方法模式 抽象工厂模式
• 结构型模式： 适配器模式 装饰器模式 代理模式
• 行为型模式： 迭代器模式 观察者模式 模板模式 解释器模式

装饰器模式Decorator

工程中使用原因：在软件开发过程之中，有时想用一些现存的组件。这些组件可能只完成了一些核心功能。但是再不改变其结构的情况下，可以动态的扩展其功能。所有这些都可以采用装饰器实现。

优点

• 继承的有力补充，比继承灵活，在不改变原有对象的情况下，动态的给对象扩展功能
• 通过使用不同装饰类以及这些装饰类的排列组合，可以实现不同效果
• 完全遵守开闭原则

缺点

• 过度使用会增加许多子类，增加程序的复杂性

UML

实例

class Pancake
{
public:
	virtual std::string getDescription()
	{
		return m_discri;
	}

	virtual int allCost() = 0;
	virtual ~Pancake(){}
protected:
	std::string m_discri = "Basic Pancake";
};

//concrate component 具体的需要被修饰的对象
//肉煎饼
class MeatPancake:public Pancake
{
public:
	MeatPancake()
	{
		m_discri = "MeatPancake";
	}
	virtual int allCost() override
	{
		return 6;
	}
	virtual ~MeatPancake() {}
};

//鸡蛋煎饼
class EggPancake :public Pancake
{
public:
	EggPancake()
	{
		m_discri = "EggPancake";
	}

	virtual int allCost() override
	{
		return 5;
	}
	virtual ~EggPancake() {}
};

//decorator 装饰器基类 
class CondimentDecorator :public Pancake
{
};

class Egg :public CondimentDecorator
{
public:
	explicit Egg(Pancake * pancake):m_pancake(pancake){}
	virtual std::string getDescription() override
	{
		return m_pancake->getDescription() + ",Egg";
	}
	virtual int allCost() override
	{
		return m_pancake->allCost() + 1;
	}
	virtual ~Egg() {}
private:
	Pancake* m_pancake;


};

#include<memory>
#include"Decorator.hpp"
int main()
{
	Pancake* pancake = new EggPancake();
	std::cout << pancake->getDescription() << std::endl;
	pancake = new Egg(pancake);
	std::cout<<pancake->getDescription() << std::endl;
	delete pancake;
	return 0;
}

代理模式

为其他对象提供一种代理以控制对这个对像的访问

分类

• 远程代理 为一个对象在不同的地址空间提供局部代表 可以隐藏一个对象存在于不同空间地址的事实
• 虚拟代理 根据需要创建开销很大的对象 通过它来存放实例化需要很长时间的真实对象
  
• 安全代理 控制真实对象的访问权限
• 智能指引 调用真实对象时，代理处理另外一些事情

UML

迭代器模式

提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示

观察者模式

说明

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

结构

URL

实例

#include<iostream>
#include<list>
#include<string>
#include<memory>

class Observer
{
public:
	virtual void update() = 0;
	virtual ~Observer(){}
};

/*抽象目标类
提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。*/
class Subject
{
public:
	void attachObserver(std::shared_ptr<Observer> observer)
	{
		m_observers.push_back(observer);
	}

	void detachObserver(std::shared_ptr<Observer> observer)
	{
		m_observers.remove(observer);
	}

	void notify()
	{
		for (auto& observer : m_observers) {
			observer->update();
		}
	}
private:
	std::list<std::shared_ptr<Observer>> m_observers;

};


/*具体目标类
实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。*/
class ConcreteSubject :public Subject
{
public:
	std::string getState()
	{
		return m_subjectState;
	}

	void setState(const std::string&& state)
	{
		m_subjectState = state;
	}
private:
	std::string m_subjectState;
};

class ConcreteObserver :public Observer
{
public:
	explicit ConcreteObserver(std::shared_ptr<ConcreteSubject> observerState, std::string name)
		:m_subjectPtr(observerState)
		, m_name(name)
	{
	}

	virtual void update() override
	{
		m_observerState = m_subjectPtr->getState();
		std::cout << "observer: " << m_name << ",its new state is: " << m_observerState << std::endl;
	}

	std::string getState()
	{
		return m_observerState;
	}

	void setState(const std::string&& state)
	{
		m_observerState = state;
	}

private:
	std::string m_name;
	std::shared_ptr<ConcreteSubject> m_subjectPtr;//观察者具体观察的对象
	std::string m_observerState;
};

/*-----------------------------*/
#include<memory>
#include"Decorator.hpp"
#include"Observer.hpp"
int main()
{
	//观察者模式测试
	//被观察的对象
	std::shared_ptr<ConcreteSubject> conSubject(new ConcreteSubject());
	conSubject->setState("abc");
	//具体的观察者
	std::shared_ptr<ConcreteObserver> obs1(new ConcreteObserver(conSubject, "one"));
	std::shared_ptr<ConcreteObserver> obs2(new ConcreteObserver(conSubject, "two"));

	conSubject->attachObserver(obs1);
	conSubject->attachObserver(obs2);
	conSubject->notify();

	conSubject->setState("def"); 
	conSubject->notify();

	return 0;
}

解释器模式

• 给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。
• 主要解决： 对于一些固定文法构建一个解释
• 句子的解释器。
• 主要应用： SQL解析 符号处理引擎