//3.装饰模式
//ver1
class Person
{
private:
	string _name;
public:
	Person(string name)
	{
		_name = name;
	}
	void Show()
	{
		//...
	}
};

//服饰抽象类
class Finery
{
public:
	virtual void Show() = 0;
};

//T恤类
class TShirts : public Finery
{
public:
	virtual void Show()
	{
		//..
	}
};

//垮裤类
class BigTrouser : public Finery
{
public:
	virtual void Show()
	{
		//..
	}
};

//领带类
class Tie : public Finery
{
public:
	virtual void Show()
	{
		//..
	}
};

void main11()
{
	Person *ppc = new Person("fun");
	TShirts *pd1 = new TShirts();
	BigTrouser *pd2 = new BigTrouser();
	Tie *pd3 = new Tie();

	//装扮1
	pd1->Show();
	pd2->Show();
	ppc->Show();
	//装扮2
	pd1->Show();
	pd3->Show();
	ppc->Show();
	//缺点: 一个一个显示出来; 组装应该在内部进行; 
}

//装饰模式: 动态地给一个对象添加一些额外的职责，就增加功能类说，装饰模式比生成子类更为灵活;

//3.装饰模式
//ver2

//Component是定义一个对象接口，可以给这些对象动态地添加职责。
//ConcreteComponent是定义一个具体的对象，也可以给这个对象添加一些职责。
//Decorator抽象装饰类，继承了Component，从外类来扩展Component类的功能，但对于Component来说，无需知道Decorator的存在;
//ConcreteDecorator就是具体的装饰对象，起到给Component添加职责的功能。

class Component
{
public:
	virtual void Operation() = 0; //接口
};

class ConcreteComponent : public Component
{
	virtual void Operation()
	{
		//...
	}
};

class Decorator : public Component
{
protected:
	Component *pcomponent;
public:
	void SetComponent(Component *pcom)
	{
		pcomponent = pcom;
	}
	virtual void Operation()
	{
		if (pcomponent != NULL)
		{
			pcomponent->Operation();
		}
	}
};

class ConcreteDecoratorA : public Decorator
{
private:
	string addState;
public:
	virtual void Operation()
	{
		Decorator::Operation(); //先运行Component的Operation，再执行本类的操作。
		addState = "New State";
		//...
	}
};

class ConcreteDecoratorB : public Decorator
{
private:
	void AddBehavior() //本类独有的操作;
	{
		//...
	}
public:
	virtual void Operation()
	{
		Decorator::Operation();
		AddBehavior();
	}
};

void main12()
{
	ConcreteComponent * pc = new ConcreteComponent();
	ConcreteDecoratorA * d1 = new ConcreteDecoratorA();
	ConcreteDecoratorB * d2 = new ConcreteDecoratorB();

	d1->SetComponent(pc); //先用 ConcreteDecoratorA 来包装 ConcreteComponent; 会执行 ConcreteComponent::Operation()
	d2->SetComponent(d1); //再用 ConcreteDecoratorB 来包装 ConcreteDecoratorA
	d2->Operation(); //最终执行 d2->Operation()
	//装饰模式是利用SetComponent来对对象进行包装的。这样每个装饰对象的实现就和如何使用这个对象分离开了。
	//每个装饰对象只关心自己的功能，不需要关心如何被添加到对象链当中。
}

//如果只有一个ConcreteComponent类而没有抽象的Component类，那么Decorator类可以是ConcreteComponent的一个子类。
//如果只有一个ConcreteDecorator类，那么久没有必要建立一个单独的Decorator类，而可以把Decorator和ConcreteDecorator的责任合成一个类.