设计模式（1）

单例模式：保证为一个类只生成唯一的实例对象。也就是说在整个程序空间中该类只存在一个实例对象。

>

 #include <iostream>

using namespace std;

class UserManager
{
private:
    UserManager()
    {

    }
public:
    static UserManager* GetInstance()
    {
        if(m_instance ==NULL)
            m_instance = new UserManager;
        return m_instance;
    }
private:
    static UserManager *m_instance;
};
UserManager *UserManager::m_instance = new UserManager;

int main()
{
    UserManager *p1 = UserManager::GetInstance();
}

简单工厂：
静态工厂方法模式。通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类

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

class Operator
{
public:
    virtual int GetResult(int a, int b) = 0;
};

class Add:public Operator
{
public:
    int GetResult(int a, int b)
    {
        return a+b;
    }
};
class Sub:public Operator
{
public:
    int GetResult(int a, int b)
    {
        return a-b;
    }
};
// 工厂类：负责创建对象
class Factory
{
public:
    Operator *CreateOperator(string str)
    {
        if (str == "加法")
            return new Add;`这里写代码片`

        if (str == "减法")
            return new Sub;
    }
};

int main()
{
    Factory *pf = new Factory;                   // 创建一个工厂
    Operator *opt1 = pf->CreateOperator("加法");  // 从工厂获取对象
    cout << opt1->GetResult(10,20) << endl;

    Operator *opt2 = pf->CreateOperator("减法");  // 从工厂获取对象
    cout << opt2->GetResult(10,20) << endl;

    return 0;
}

工厂模式：工厂方法模式同样属于类的创建型模式又被称为多态工厂模式 。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。
核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

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

class Operator
{
public:
    virtual int GetResult(int a, int b) = 0;
};

class Add:public Operator
{
public:
    int GetResult(int a, int b)
    {
        return a+b;
    }
};
class Sub:public Operator
{
public:
    int GetResult(int a, int b)
    {
        return a-b;
    }
};

// 工厂的基类
class AbsFactory
{
public:
    virtual Operator *CreateOperator() = 0;
};

// 加法工厂
class Factory_Add:public AbsFactory
{
public:
    Operator *CreateOperator()
    {
        return new Add;
    }
};

// 减法工厂
class Factory_Sub:public AbsFactory
{
public:
    Operator *CreateOperator()
    {
        return new Sub;
    }
};

int main()
{
    AbsFactory *pf1 = new Factory_Add;            // 创建一个加法工厂
    Operator *opt1 = pf1->CreateOperator();       // 从加法工厂获取对象
    cout << opt1->GetResult(10,20) << endl;

    AbsFactory *pf2 = new Factory_Sub;             // 创建一个减法工厂
    Operator *opt2 = pf2->CreateOperator();        // 从减法工厂获取对象
    cout << opt2->GetResult(10,20) << endl;

    return 0;
}

建造者模式：
Builder模式也叫建造者模式或者生成器模式，是由GoF提出的23种设计模式中的一种。Builder模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。
对象的创建：Builder模式是为对象的创建而设计的模式- 创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象- 关注对象创建的各部分的创建过程：不同的工厂（这里指builder生成器）对产品属性有不同的创建方法
class A
{
private：
B *b;
}

    #include <iostream>
2   #include <vector>
3#include <string>
4   using namespace std;
5
6// 产品
7class Person
8{
9public:
10void add(string part)
11{
12parts.push_back(part);
13}
14
15void show()
16{
17for (unsigned int i = 0; i < parts.size(); i++)
18{
19  cout << parts[i] << endl;
20}
21}
22private:
23vector<string> parts;
24};
25
26// 建造者抽象类：建造产品的各个部分
27class Builder
28{
29public:
30virtual void BuilderHead() = 0;
31virtual void BuilderBody() = 0;
32virtual void BuilderHand() = 0;
33virtual void BuilderFeet() = 0;
34virtual Person* GetResult() = 0;
35};
36
37// 负责创建胖子的建造者
38class FatPersonBuilder:public Builder
39{
40public:
41FatPersonBuilder()
42{
43person = new Person;
44}
45virtual void BuilderHead()
46{
47person->add("胖人的头");
48}
49virtual void BuilderBody()
50{
51person->add("胖人的身体");
52}
53virtual void BuilderHand()
54{
55person->add("胖人的手");
56}
57virtual void BuilderFeet()
58{
59person->add("胖人的脚");
60}
61virtual Person* GetResult()
62{
63return person;
64}
65private:
66Person *person;
67};
68
69class ThinPersonBuilder:public Builder
70{
71public:
72ThinPersonBuilder()
73{

74person = new Person;
75}
76virtual void BuilderHead()
77{
78person->add("瘦人的头");
79}
80virtual void BuilderBody()
81{
82person->add("瘦人的身体");
83}
84virtual void BuilderHand()
85{
86person->add("瘦人的手");
87}
88virtual void BuilderFeet()
89{
90person->add("瘦人的脚");
91}
92virtual Person* GetResult()
93{
94return person;
95}
96private:
97Person *person;
98};
99
100// 指挥者：指挥 "建造者" 干活，指挥者本身不包含产品内容
101class Director
102{
103public:
104void Concrete(Builder *builder)
105{
106builder->BuilderHead();
107builder->BuilderBody();
108builder->BuilderHand();
109builder->BuilderFeet();
110}
111};
112
113int main()
114{
115 Director *diector = new Director;       // 指挥者
116 Builder *pb1 = new ThinPersonBuilder;   // 造瘦人的建造者
117         建造过程
118 diector->Concrete(pb1); //  
119             
120Person *p1 = pb1->GetResult();  // 拿产品
121p1->show();
122
123Builder *pb2 = new FatPersonBuilder;
124diector->Concrete(pb2);
125Person *p2 = pb2->GetResult();  // 拿产品
126p2->show();
127
128return 0;
129}