#include <iostream>
#include <boost/smart_ptr.hpp>using namespace std;class Parent;
class Children;class Parent
{
public:Parent(){cout << "parent create" << endl;}~Parent(){cout << "parent destroy" << endl;}boost::shared_ptr<Children> c;
};class Children
{
public:Children(){cout << "children create" << endl;}~Children(){cout << "children destroy" << endl;}boost::shared_ptr<Parent> p;
};void test()
{boost::shared_ptr<Parent> p(new Parent);boost::shared_ptr<Children> c(new Children);p->c = c;c->p = p;
}void main()
{test();cin.get();
}

首先，在设计初期阶段，应该要有意识将不同的两个层分离，，层与层之间建立外观Facade，
其次。在开发阶段，子系统往往由于不断的重构演化而变得越来越复杂。添加外观模式，降低依赖。
第三，维护一个一流的大型系统的时候，可能这个系统已经很难以维护和扩展了，就要改动设计，让新系统与Facade对象交互。Facade与遗留代码交互全部复杂工作。

MVC不就是採用的这个模式吗.分层思想。

。。

建造者模式：上图。

这个建造者模式的精髓主要用于创建一些复杂的最想。这些对象内部构建间的建造顺序一般是稳定的，但对象内部的构建通常面临着复杂的变化。

这个内部非常复杂。可是这些东西都是Director来做的。Client不用管，Client管的就是依照接口一个一个的把方法实现即可了，然后用Director来创建对象，最后产品就出来了。

优点：使建造代码与表示代码分离。因为建造者隐藏了该产品是怎样组装的，所以假设须要改变一个产品的内部表示。仅仅须要再定义一个详细的建造者就能够了。

所以说,建造者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式时使用的模式.

事实上我们在android里的AlertDialog.Builder不也非常相似吗，我们没有关注细节，最后build除了那个dialog

建造者模式代码：

#include <iostream>using namespace std;class Product
{
public :char *head = nullptr;char *body = nullptr;friend ostream & operator<<(ostream & os, Product & pro){os << pro.head << "   " << pro.body;return os;}
};class Builder
{
protected:Product *p = nullptr;
public:Builder(){p = new Product;}~Builder(){delete p;}
public:virtual Product & getResult(){return *p;}virtual void buildPartA() = 0;virtual void buildPartB() = 0;
};class BuilderA : public Builder
{
public:virtual void buildPartA() override{p->head = "大头";}virtual void buildPartB() override{p->body = "金身";}
};class BuilderB : public Builder
{
public:virtual void buildPartA() override{p->head = "小头";}virtual void buildPartB() override{p->body = "測试";}
};class Director
{
public:void build(Builder & b){b.buildPartA();b.buildPartB();}
};void main_jianzao()
{Builder *b1 = new BuilderA;Builder *b2 = new BuilderB;Director dir;dir.build(*b1);dir.build(*b2);Product &p1 = b1->getResult();Product &p2 = b2->getResult();cout << p1 << endl;cout << p2 << endl;cin.get();
}

观察者模式：上图：

今天晚上用c++调了半天，最后还是有点小问题。明天再调吧，今天实在是困得不行不行了。

我们说完，观察者模式就是我们常说的监听。事实上监听器就是依据这个模式来的。

当一个对象的改变须要同一时候改变其它对象的时候就须要我们考虑用观察者模式了，
并且他不知道详细有多少对象有待改变的时候，应该考虑使用观察者模式。

观察者模式所做的工作就是在解除耦合.让耦合两方都依赖于抽象,而不是依赖于详细,从而使得各自的变化都不会影响还有一边的变化.

观察者模式代码例如以下：

#include <iostream>
#include <vector>
#include <algorithm>
#include <boost/smart_ptr.hpp>
#include <memory>using namespace std;class Observer;
class TongshiA;
class TongshiB;
class Event;
template<class T>
class AbstractSubject;class Secretary;
class Boss;class Event
{
public:string type = nullptr;string content = nullptr;Event(){}Event(string &type, string & content) :type(type), content(content){}
};template<class T>
class AbstractSubject
{
protected:vector<T *> *obsevers = nullptr;public:virtual void attch(T * p){obsevers->push_back(p);}virtual void detach(T * p){remove(obsevers->begin(), obsevers->end(), p);}virtual void notifyall() = 0;AbstractSubject(){obsevers = new vector<T*> ;}~AbstractSubject(){delete obsevers;}};class Observer
{
public:const char *name;Observer(const char *name) :name(name){}virtual void update(Event & e){cout << "消息内容:" << e.content.c_str() << endl;}
};class TongshiA : public Observer
{
public:TongshiA(const char * name) :Observer(name){}virtual void update(Event & e) override{cout << "消息内容:" << e.content.c_str() << endl;if (strcmp(e.type.c_str(), "警报") == 0){cout << "关闭游戏，继续工作" << endl;}else{cout << "反正老板也没回来，去刷副本" << endl;}}
};class TongshiB : public Observer
{
public:TongshiB(const char *name) :Observer(name){}virtual void update(Event & e) override{cout << "消息内容:" << e.content.c_str() << endl;if (strcmp(e.type.c_str(), "警报") == 0){cout << "最小化股票，好好工作" << endl;}else{cout << "和同事还能聊会儿天" << endl;}}
};class Secretary : public AbstractSubject<Observer>
{
public:virtual void attch(Observer * t){obsevers->push_back(t);}virtual void detach(Observer * t){remove(obsevers->begin(), obsevers->end(), t);}virtual void notifyall() override{for_each(obsevers->begin(), obsevers->end(), [&](Observer * obs){string s1("警报");string s2("老板来了");Event e(s1, s2);obs->update(e);});}
};class Boss : public AbstractSubject < Observer >
{
public:virtual void attch(Observer * t){obsevers->push_back(t);}virtual void detach(Observer * t){remove(obsevers->begin(), obsevers->end(), t);}virtual void notifyall() override{for_each(obsevers->begin(), obsevers->end(), [&](Observer * obs){string s1("正常");string s2("老板出去了");Event e(s1,s2);obs->update(e);});}
};void main()
{AbstractSubject<Observer> *sec = new Secretary;Observer *a = new TongshiA("tongshia");Observer *b = new TongshiB("tongshib");sec->attch(a);sec->attch(b);AbstractSubject<Observer> *boss = new Boss;boss->attch(a);boss->attch(b);sec->notifyall();cout << "---------------------------------" << endl;boss->notifyall();cin.get();
}

实在是困了，这了快2点了，明天正常的话要7点多起床。看来要8点起床了。已经刷完牙啦。准备睡觉。各位看官都这个点了，早点睡吧，我去睡觉了，晚安~