《C++设计模式》——创建型

前言

创建型为了创建东西才是有用的，创建型设计模式使用的场景：
1、创建一个东西；
2、可重复利用；
3、灵活性高，代码可因地制宜。

Factory Method(工厂模式)

工厂模式将目的将创建对象的具体过程屏蔽隔离起来，从而达到更高的灵活性，工厂模式可以分为三类：

• 简单工厂模式(Simple Factory)
• 工厂方法模式(Factory Method)
• 抽象工厂模式(Abstract Factory)

这三种模式从上到下逐步抽象，并且更具一般性。《设计模式》一书中将工厂模式分为两类：工厂方法模式与抽象工厂模式。将简单工厂模式看为工厂方法模式的一种特例，两者归为一类。

Simple Factory(简单工厂)

主要用于创建对象。新添加类时，不会影响以前的系统代码。核心思想是用一个工厂来根据输入的条件产生不同的类，然后根据不同类的 virtual 函数得到不同的结果。
GOOD：适用于不同情况创建不同的类时
BUG：客户端必须要知道基类和工厂类，耦合性差

simpleFactory.h

#ifndef CLION_TEST_SIMPLEFACTORY_H
#define CLION_TEST_SIMPLEFACTORY_H

//基类
class COperation {
public:
    int m_nFirst;
    int m_nSecond;

    virtual double GetResult() {
        double dResult = 0;
        return dResult;
    }
};

//加法
class AddOperation : public COperation {
public:
    double GetResult() final {
        return m_nFirst + m_nSecond;
    }
};

//减法
class SubOperation : public COperation {
public:
    double GetResult() final {
        return m_nFirst - m_nSecond;
    }
};

//工厂类
class CCalculatorFactory {
public:
    static COperation *Create(char cOperator) {
        COperation *oper;
        switch (cOperator) {
            case '+':
                oper = new AddOperation();
                break;
            case '-':
                oper = new SubOperation();
                break;
            default:
                oper = new AddOperation();
                break;
        }
        return oper;
    }
};

#endif //CLION_TEST_SIMPLEFACTORY_H

main.cpp

#include 
#include "simpleFactory.h"

using namespace std;

int main() {

    int a = 1;
    int b = 2;
    COperation * op=CCalculatorFactory::Create('-');
    op->m_nFirst=a;
    op->m_nSecond=b;
    cout<<op->GetResult()<<endl;
    return 0;
}

Factory Method(工厂方法)

GOOD：修正了简单工厂模式中不遵守开放－封闭原则。工厂方法模式把选择判断移到了客户端去实现，如果想添加新功能就不用修改原来的类，直接修改客户端即可。
一个产品对应一个工厂类。

factorymethod.h

#ifndef CLION_TEST_FACTORYMETHOD_H
#define CLION_TEST_FACTORYMETHOD_H

#include 
#include 

using namespace std;

// 实例基类，相当于Product
class LeiFeng {
public:
    virtual void Sweep() {
        cout << "雷锋扫地" << endl;
    }
};

// 学雷锋的大学生，相当于ConcreteProduct
class Student : public LeiFeng {
public:
    void Sweep() final {
        cout << "大学生扫地" << endl;
    }
};

// 学雷锋的志愿者，相当于ConcreteProduct
class Volenter : public LeiFeng {
public:
    void Sweep() final {
        cout << "志愿者" << endl;
    }
};

// 工厂基类 Creator
class LeiFengFactory {
public:
    virtual LeiFeng *CreateLeiFeng() {
        return new LeiFeng();
    }
};

// 工厂具体类
class StudentFactory : public LeiFengFactory {
public:
    LeiFeng *CreateLeiFeng() final {
        return new Student();
    }
};

class VolenterFactory : public LeiFengFactory {
public:
    LeiFeng* CreateLeiFeng() final {
        return new Volenter();
    }
};

#endif //CLION_TEST_FACTORYMETHOD_H

main.cpp

#include "factorymethod.h"

using namespace std;

int main() {
    // 工厂方法
    LeiFengFactory *sf = new StudentFactory();
    LeiFeng *s = sf->CreateLeiFeng();
    s->Sweep();
    delete sf;
    delete s;
    sf = nullptr;
    s = nullptr;
    return 0;
}

Abstract Factory(抽象工厂)

Builder(建造者)

Prototype(原型)

GOOD：从一个对象再创建另外一个可定制的对象，而无需知道任何创建的细节。并能提高创建的性能。 说白了就 COPY 技术，把一个对象完整的 COPY 出一份。
注：此处书写的是浅拷贝，当需要复制的内容更改时不影响原先的内容，需要进行深拷贝，好奇地是原型模式直接使用拷贝赋值或拷贝构造函数不就可以了嘛。

prototype.h

#ifndef CLION_TEST_PROTOTYPE_H
#define CLION_TEST_PROTOTYPE_H

#include 
#include 
#include 

using namespace std;

// 抽象基类
class Prototype {
private:
    string m_strName;
public:
    Prototype(string strName) { m_strName = strName; }

    Prototype() { m_strName = ""; }

    void Show() {
        cout << m_strName << endl;
    }

    virtual Prototype *Clone() = 0;
};

// class ConcretePrototype1
class ConcretePrototype1 : public Prototype {
public:
    ConcretePrototype1(string strName) : Prototype(strName) {}

    ConcretePrototype1() {}

    Prototype *Clone() final {
        ConcretePrototype1 *p = new ConcretePrototype1();
        *p = *this; // 复制对象
        return p;
    }
};

// class ConcretePrototype2
class ConcretePrototype2 : public Prototype {
public:
    ConcretePrototype2(string strName) : Prototype(strName) {}

    ConcretePrototype2() {}

    Prototype *Clone() final {
        ConcretePrototype2 *p = new ConcretePrototype2();
        *p = *this; // 复制对象
        return p;
    }
};

#endif //CLION_TEST_PROTOTYPE_H

main.cpp

#include 
#include "prototype.h"

using namespace std;

int main() {
    system("chcp 65001");
    // 客户端
    ConcretePrototype1* test1 = new ConcretePrototype1("小王");
    ConcretePrototype2* test2 = (ConcretePrototype2*)test1->Clone();
    test1->Show();
    test2->Show();
    return 0;
}

Singleton(单例)

后记