工厂模式 ---- 简单工厂模式和抽象工厂模式

简单工厂模式

/*
 * 简单工厂模式
 *
 * 优点：
帮助封装
实现组件封装，面向接口编程
解耦合
客户端和具体实现类的解耦合

缺点：
可能增加客户端的复杂度
不方便扩展子工厂
 */


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

//产品抽象父类
class Operation{
public:
    double a;
    double b;

    virtual double calculate_a_b() = 0;

};

class AddOperation:public Operation{
    double calculate_a_b(){
        return a + b;
    }
};

class SubOperation:public Operation{
    double calculate_a_b(){
        return a - b;
    }
};

class DivOperation:public Operation{
    double calculate_a_b(){
        return a / b;
    }
};

class MulOperation:public Operation{
    double calculate_a_b(){
        return a * b;
    }
};

//产品工厂类
class OperationFactory{
public:
    static Operation* createOperation(char c){
        switch (c) {
            case '+':
                return new AddOperation;
            case '-':
                return new SubOperation;
            case '/':
                return new DivOperation;
            case '*':
                return new MulOperation;
            default:
                return nullptr;
        }
    }
};

int main(){
    Operation* operation = OperationFactory::createOperation('+');

    if(operation != nullptr){
        operation->a = 1.5;
        operation->b = 2.5;

        double result = operation->calculate_a_b();

        cout << result << endl;
    }
    else{
        cout << "nullptr" << endl;
    }


}

抽象工厂模式

/*抽象工厂模式

优点：
抽象工厂封装了变化，封装了对象创建的具体细节
增加新的产品族很方便，无须修改已有系统
针对接口进行编程而不是针对具体进行编程

缺点：
增加新的产品等级结构需对原系统做较大修改(违背开放封闭)

 */

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

//抽象产品
class Product{
public:
    virtual void show() = 0;
};

//A产品
class A_Product:public Product{};
//B产品
class B_Product:public Product{};

//M公司的A产品
class M_A_Product: public A_Product{
    void show(){
        cout << "M Factory A Product" << endl;
    }
};
//M公司的B产品
class M_B_Product:public B_Product{
    void show(){
        cout << "M Factory B Product" << endl;
    }
};

//N公司的A产品
class N_A_Product:public A_Product{
    void show(){
        cout << "N Factory A Product" << endl;
    }
};
//N公司的B产品
class N_B_Product:public B_Product{
    void show(){
        cout << "N Factory B Product" << endl;
    }
};

//抽象工厂
class Factory{
public:
    virtual A_Product* create_A() = 0;
    virtual B_Product* create_B() = 0;
};

//M 工厂
class M_Factory:public Factory{
    A_Product* create_A(){
        return new M_A_Product;
    }

    B_Product* create_B(){
        return new M_B_Product;
    }
};


//N 工厂
class N_Factory:public Factory{
    A_Product* create_A(){
        return new N_A_Product;
    }

    B_Product* create_B(){
        return new N_B_Product;
    }
};

int main(){
    Factory* factory_M = new M_Factory;

    A_Product* m_a_product = factory_M->create_A();
    B_Product* m_b_product = factory_M->create_B();

    m_a_product->show();
    m_b_product->show();

    delete factory_M;
    delete m_a_product;
    delete m_b_product;



    Factory* factory_N = new N_Factory;

    A_Product* n_a_product = factory_N->create_A();
    B_Product* n_b_product = factory_N->create_B();

    n_a_product->show();
    n_b_product->show();

    delete factory_N;
    delete n_a_product;
    delete n_b_product;

}