设计模式之 建造者模式 &&观察者模式

建造者模式：
将一个复杂对象的构建和他的表示分离，使得同样的构建过程可以创建不同的表示;

建造者模式的使用情况：
主要用于创建一些复杂的对象，这些对象内部构建间的建造顺序通常是稳定的，但对象内部的构建通常面临着复杂的变化。
建造模式ide好处：
使得建造代码与表示代码分离，由于建造隐藏了该产品是如何组装的，所以若需改变一个产品的内部表示，只需在定义一个具体的建造者就可以了。

---

示例一：

//建造者模式
// 示例一:
//建造胖人和瘦人。先弄一个构建人的抽象基类。
//然后创建胖人和兽人类，由基类继承而来，为了隐藏客户端调用类方法的细节，在创建一个指挥者类，来创建表示
#include<iostream>
using namespace std;
#include<vector>
#include<string>


class Person
{
public:
    virtual void buildHead() { cout << "头" << endl; }
    virtual void buildBody() { cout << "身体" << endl; }
    virtual void buildArmleft() { cout << "左臂" << endl; }
    virtual void buildArmright() { cout << "右臂" << endl; }
    virtual void buildLegleft() { cout << "左腿" << endl; }
    virtual void buildLegright() { cout << "右腿" << endl; }

};


class BuildthinPerson :public Person
{
    void buildHead() { cout << "胖头" << endl; }
    void buildBody() { cout << "胖身体" << endl; }
    void buildArmleft() { cout << "胖左臂" << endl; }
    void buildArmright() { cout << "胖右臂" << endl; }
    void buildLegleft() { cout << "胖左腿" << endl; }
    void buildLegright() { cout << "胖右腿" << endl; }

};

class BuilfatPerson :public Person
{
    void buildHead() { cout << "胖头" << endl; }
    void buildBody() { cout << "胖身体" << endl; }
    void buildArmleft() { cout << "胖左臂" << endl; }
    void buildArmright() { cout << "胖右臂" << endl; }
    void buildLegleft() { cout << "胖左腿" << endl; }
    void buildLegright() { cout << "胖右腿" << endl; }

};

//指挥者
class Director
{
private:
    Person* person;
public:
    void construct(Person& person)
    {
        this->person = &person;
    }
    void creatPerson()
    {
        person->buildHead();
        person->buildBody();
        person->buildArmleft();
        person->buildArmright();
        person->buildLegleft();
        person->buildLegright();
    }
};

int main()
{
    BuilfatPerson fatPerson;//创建胖人类对象
    Director director;//创建指挥者对象
    director.construct(fatPerson);
    director.creatPerson();
    system("pause");
    return 0;
}

输出是：
胖头
胖身体
胖左臂
胖右臂
胖左腿
胖右腿

---

示例二：

//示例二：
#include<string>
#include<vector>
#include<iostream>
using namespace std;


class Product
{
private:
    vector<string>product;
public:
    void add(string str)
    {
        product.push_back(str);
    }
    void show()
    {
        vector<string>::iterator iter = product.begin();//迭代器指针指向产品的第一个
        while (iter != product.end())//没有遍历到最后一个
        {
            cout << *iter << "　";//输出迭代器指向的内容
            ++iter;//递增迭代器 继续遍历下一个
        }
        cout << endl;
    }
};


class Builder 
{

public:
    //构造纯虚函数
    virtual void builderA() = 0;
    virtual void builderB() = 0;
    virtual Product* getResult() = 0;
};


class ConcreteBuilder1 :public Builder
{
private:
    Product* product;
public:
    ConcreteBuilder1()
    {
        product = new Product();
    }
    virtual void builderA()
    {
        product->add("one");
    }
    virtual void builderB()
    {
        product->add("two");
    }
    virtual Product* getResult()
    {
        return product;
    }
};


class ConcreteBuilder2 :public Builder
{
private:
    Product* product;
public:
    ConcreteBuilder2()
    {
        product = new Product();
    }
    virtual void builderA()
    {
        product->add("A");
    }
    virtual void builderB()
    {
        product->add("B");
    }
    virtual Product* getResult()
    {
        return product;
    }
};


class Director
{
private:
    Product* p;
public:
    void construct(Builder* bd)
    {
        bd->builderA();
        bd->builderB();
        p = bd->getResult();
    }
    Product* getResult()
    {
        return p;
    }
};


int main()
{
    Director* director = new Director();
    Builder* bd1 = new ConcreteBuilder1();

    director->construct(bd1);
    Product* pbd1 = director->getResult();
    pbd1->show();

    system("pause");
    return 0;

}

输出：
one two

---

补充一些关于STL迭代器的知识：
1 STL六大组件

STL大体分为六大组件，分别是:容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据。
算法：各种常用的算法，如sort、find、copy、for_each等
迭代器：扮演了容器与算法之间的胶合剂。
仿函数：行为类似函数，可作为算法的某种策略。
适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。
空间配置器：负责空间的配置与管理

---

2 STL中容器、算法、迭代器

容器 置物之所也

STL容器就是将运用最广泛的一些数据结构实现出来

常用的数据结构：数组, 链表,树, 栈, 队列, 集合, 映射表 等

这些容器分为序列式容器和关联式容器两种:

​ 序列式容器:强调值的排序，序列式容器中的每个元素均有固定的位置。
关联式容器:二叉树结构，各元素之间没有严格的物理上的顺序关系

算法 问题之解法也

有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(Algorithms)

算法分为:质变算法和非质变算法。

质变算法：是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等等

非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等

迭代器： 容器和算法之间粘合剂

起到遍历容器内所有元素的作用，并返回迭代器指向的元素；

提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。

每个容器都有自己专属的迭代器

迭代器使用非常类似于指针，初学阶段我们可以先理解迭代器为指针

迭代器的种类：

下面看下迭代器的几种实现方法：

#include <vector>
#include <algorithm>

void MyPrint(int val)
{
	cout << val << endl;
}

void test01() {

	//创建vector容器对象，并且通过模板参数指定容器中存放的数据的类型
	vector<int> v;
	//向容器中放数据
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);

	//每一个容器都有自己的迭代器，迭代器是用来遍历容器中的元素
	//v.begin()返回迭代器，这个迭代器指向容器中第一个数据
	//v.end()返回迭代器，这个迭代器指向容器元素的最后一个元素的下一个位置
	//vector<int>::iterator 拿到vector<int>这种容器的迭代器类型

	vector<int>::iterator pBegin = v.begin();
	vector<int>::iterator pEnd = v.end();

	//第一种遍历方式：
	while (pBegin != pEnd) {
		cout << *pBegin << endl;
		pBegin++;
	}
	
	//第二种遍历方式：
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << endl;
	}
	cout << endl;

	//第三种遍历方式：
	//使用STL提供标准遍历算法  头文件 algorithm
	for_each(v.begin(), v.end(), MyPrint);
}

int main() {

	test01();

	system("pause");
	return 0;
}

---

1 指针与取地址

int *p=#//指针p指向num的地址

这里int*p定义了一个指向int类型指针p;
并初始化p使其指向int类型的变量num,&是取地址操作符，当&作用于一个对象时，它返回该对象的地址

2 使用指针—解引用与指针赋值

int main()
{
    int num = 7;
    int* p = #//p指向num所在的地址
    cout << "数值" << num << "所在的地址是：" << p << endl;
    cout << "指针" << p << "指向的地址所保存的值是" << *p << endl;//*p是对指针p解引用 返回的是指针p指向的地址保存的值
    *p = 100;//重新对指针指向的地址保存的值赋新值
    cout << "指针" << p << "现在指向的地址所保存的值是" << *p << endl;
    system("pause");
    return 0;

}

输出是:
数值7所在的地址是：00AFFE58
指针00AFFE58指向的地址所保存的值是7
指针00AFFE58现在指向的地址所保存的值是100

---

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

观察者模式特点：
将一个系统分割成一系列像话写作的类有一个很不好的副作用那就是需要维护相关对象的一致性，我们不希望为了维持一致性而使各类紧密耦合
当一个对象改变需要同时改变其他对象时，而且它不知道具体有多少个对象改变时，应该考虑使用观察者模式。
一个抽象模型有两个方面，其中一个方面依赖于另一个方面，这时用观察者模式可以将这两者封装在独立的对象中是他们各自独立的改变和复用。
观察者模式所做的工作其实就是在解除耦合，让耦合的双方依赖于抽象，而不是依赖于具体，从而使的各自的变化都不会影响另一边的变化。

---

代码实现：

#include<iostream>
using namespace std;
#include<vector>
#include<string>
#include<list>


class Subject;


class Observer
{
protected:

	string name;
	Subject* sub;

public:
	Observer(string name, Subject* sub)
	{
		this->name = name;
		this->sub = sub;
	}
	virtual void update() = 0;
};

//股票观察者
class StockObserver :public Observer
{
public:
	StockObserver(string name, Subject* sub) :Observer(name, sub)
	{

	}
	void update();

};

//NBA观察者
class NBAObserver :public Observer
{
public:
	NBAObserver(string name, Subject* sub) :Observer(name, sub)
	{

	}
	void update();
};

class Subject
{
protected:
	list<Observer*>observers;
public:
	string action;
	virtual void attach(Observer*) = 0;
	virtual void detach(Observer*) = 0;
	virtual void notify() = 0;

};

class Secretary :public Subject
{
	//附加
	void attach(Observer* observer)
	{
		observers.push_back(observer);
	}
	//分离
	void detach(Observer* observer)
	{
		list<Observer*>::iterator iter = observers.begin();
		while (iter != observers.end())
		{
			if ((*iter) == observer)
			{
				observers.erase(iter);
			}
			++iter;
		}
	}
	void notify()
	{
		list<Observer*>::iterator iter = observers.begin();
		while (iter != observers.end())
		{
			(*iter)->update();
			++iter;
		}
	}
};

void StockObserver::update()
{
	cout << name << "收到消息" << sub->action << endl;
	if (sub->action == "张所长来了")
	{
		cout << "我马上关闭股票，装作很认真的样子！" << endl;
	}
}

void NBAObserver::update()
{
	cout << name << "收到消息:" << sub->action << endl;
	if (sub->action == "张所长来了")
	{
		cout << "我马上关闭NBA,装作很认真的样子" << endl;

	}
}

int main()
{
	Subject* ABC = new Secretary();
	Observer* xs = new NBAObserver("小帅", ABC);
	Observer* zy = new NBAObserver("周悦", ABC);
	Observer* kb = new NBAObserver("科比", ABC);

	ABC->attach(xs);
	ABC->attach(zy);
	ABC->attach(kb);

	ABC->action = "去吃饭啦";
	ABC->notify();
	cout << endl;
	ABC->action = "张所长来了";
	ABC->notify();
	

	system("pause");
	return 0;
}

输出：
小帅收到消息:去吃饭啦
周悦收到消息:去吃饭啦
科比收到消息:去吃饭啦

小帅收到消息:张所长来了
我马上关闭NBA,装作很认真的样子
周悦收到消息:张所长来了
我马上关闭NBA,装作很认真的样子
科比收到消息:张所长来了
我马上关闭NBA,装作很认真的样子