工厂、简单工厂、抽象工厂模式（C++）

工厂模式

        定义：工厂模式是一种创建型设计模式，它提供了一种在不指定具体类的情况下创建对象的方法。主要目标是将对象的创建与使用分离，以提高代码的可扩展性和可维护性。

        优点：代码解耦、隐藏创建细节、更易于扩展、避免使用大量条件判断。

        缺点：增加了系统的复杂度、增加了代码量、在某些情况下可能不利于扩展，且不适用于所有场景。

简单工厂模式

        定义：简单工厂模式是工厂模式中最简单的一种，它通过一个工厂类来创建对象，而不需要客户端知道具体的产品类。

        优点：隐藏了对象创建的细节，将产品的实例化推迟到子类中实现；客户端基本不用关心使用的是哪个产品，只需要知道用哪个工厂；方便添加新的产品子类。

        缺点：要求产品子类的类型差不多，使用的方法名都相同；每添加一个产品子类，都必须在工厂类中添加一个判断分支，这违背了开放-封闭原则。

抽象工厂模式

        定义：抽象工厂模式是一种高级的设计模式，它提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

        优点：灵活性高、可维护性好、可靠性高。

        缺点：当产品类数据较多时，需要实现大量的工厂类，增加了代码量。

代码：

        注：为什么使用智能指针（std::shared_ptr）？由于工厂模式下，指针的创建者和使用者大概率不是同一用户，使用智能指针能够避免使用者由于疏忽没有释放指针造成的内存泄露。

//工厂模式
class Product
{
public:
    virtual void Test() = 0;
};

class ProductA : public Product
{
public:
    void Test()
    {
        cout<< "ProductA Test"<<endl;
    }
};

class ProductB : public Product
{
public:
    void Test()
    {
        cout<< "ProductA Test"<<endl;
    }
};

class Factory
{
public:
    virtual std::shared_ptr<Product> CreateProduct() = 0;
};

class FactoryA : public Factory
{
public:
    std::shared_ptr<Product> CreateProduct()
    {
        return std::make_shared<ProductA>();
    }
};

class FactoryB : public Factory
{
public:
    std::shared_ptr<Product> CreateProduct()
    {
        return std::make_shared<ProductB>();
    }
};


int main(int argc , char *argv [])
{
    Factory *factoryA = new FactoryA ();
    auto productA = factoryA->CreateProduct();
    productA->Test();

    Factory *factoryB = new FactoryB ();
    auto productB = factoryB->CreateProduct();
    productB->Test();

    delete factoryA;
    delete factoryB;
    return 0;
}

//工厂模式
enum ProductType
{
    TypeA = 0,
    TypeB,
    TypeC
};

class Product
{
public:
    virtual void Test() = 0;
};

class ProductA : public Product
{
public:
    void Test()
    {
        cout << "ProductA Test" << endl;
    }
};

class ProductB : public Product
{
public:
    void Test()
    {
        cout << "ProductB Test" << endl;
    }
};

class ProductC : public Product
{
public:
    void Test()
    {
        cout << "ProducC Test" << endl;
    }
};

class Factory
{
public:
    std::shared_ptr<Product> CreateProduct(ProductTypetype)
    {
        switch (type)
        {
        case TypeA:
            return std::make_shared<ProductA>();
        case TypeB:
            return std::make_shared<ProductB>();
        case TypeC:
            return std::make_shared<ProductC>();
        default:
            return NULL;
        }
    }
};

int main(int argc, char *argv[])
{
    Factory *ProductFactory = new Factory();
    auto productObjA = ProductFactory->CreateProduct(TypeA);
    if(productObjA.get())
        productObjA->Test();
    auto productObjB = ProductFactory->CreateProduct(TypeB);
    if(productObjB.get())
        productObjB->Test();
    auto productObjC = ProductFactory->CreateProduct(TypeC);
    if(productObjC.get())
        productObjC->Test();

    delete ProductFactory;
    return 0;
}

//抽象工厂模式
class ProductA
{
public:
    virtual void Test() = 0;
};

class ProductA1 : public ProductA
{
public:
    void Test()
    {
        cout<<"ProductA1  Test"<<endl;
    }
};

class ProductA2 : public ProductA
{
public:
    void Test()
    {
        cout<<"ProductA2  Test"<<endl;
    }
};

class ProductB
{
public:
    virtual void Test() = 0;
};

class ProductB1 : public ProductB
{
public:
    void Test()
    {
        cout<<"ProductB1  Test"<<endl;
    }
};

class ProductB2 : public ProductB
{
public:
    void Test()
    {
        cout<<"ProductB2  Test"<<endl;
    }
};

class Factory
{
public:
    virtual std::shared_ptr<ProductA> CreateProductA() = 0;
    virtual std::shared_ptr<ProductB> CreateProductB() = 0;
};

class Factory1 : public Factory
{
public:
    std::shared_ptr<ProductA> CreateProductA()
    {
        return std::make_shared<ProductA1>();
    }

    std::shared_ptr<ProductB> CreateProductB()
    {
        return std::make_shared<ProductB1>();
    }
};

class Factory2 : public Factory
{
    std::shared_ptr<ProductA> CreateProductA()
    {
        return std::make_shared<ProductA2>();
    }

    std::shared_ptr<ProductB> CreateProductB()
    {
        return std::make_shared<ProductB2>();
    }
};

int main(int argc, char *argv[])
{
    Factory *factoryObj1 = new Factory1();
    auto productObjA1 = factoryObj1->CreateProductA();
    auto productObjB1 = factoryObj1->CreateProductB();

    if(productObjA1.get())
        productObjA1->Test();
    if(productObjB1.get())
        productObjB1->Test();

    Factory *factoryObj2 = new Factory2();
    auto productObjA2 = factoryObj2->CreateProductA();
    auto productObjB2 = factoryObj2->CreateProductB();

    if(productObjA2.get())
        productObjA2->Test();
    if(productObjB2.get())
        productObjB2->Test();

    return 0;
}