C++实现简单工厂模式和抽象工厂模式

简单工厂模式：

简单工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。在简单工厂模式中，我们创建对象而无需向客户端暴露创建逻辑。这种类型的设计模式属于创建型模式，提供了一种创建对象的最佳方式。

C++代码实现：

#include <iostream>
using namespace std;

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

// 具体产品 A
class ConcreteProductA : public Product {
public:
    void Show() {
        cout << "ConcreteProductA Show" << endl;
    }
};

// 具体产品 B
class ConcreteProductB : public Product {
public:
    void Show() {
        cout << "ConcreteProductB Show" << endl;
    }
};

// 工厂类
class Factory {
public:
    Product* CreateProduct(int type) {
        switch (type) {
            case 1:
                return new ConcreteProductA();
            case 2:
                return new ConcreteProductB();
            default:
                return nullptr;
        }
    }
};

int main() {
    Factory factory;
    Product* productA = factory.CreateProduct(1);
    if (productA != nullptr) {
        productA->Show();
    }

    Product* productB = factory.CreateProduct(2);
    if (productB != nullptr) {
        productB->Show();
    }

    delete productA;
    delete productB;

    return 0;
}

抽象工厂模式：

抽象工厂模式是一种创建型设计模式，它提供了一种创建一系列相关或依赖对象的最佳方式。抽象工厂模式的基本思想是提供一个接口，用于创建与产品簇相关的一族对象，而不需要明确指定它们的类。

C++代码实现：

#include <iostream>
using namespace std;

// 抽象产品 A
class AbstractProductA {
public:
    virtual void Show() = 0;
};

// 具体产品 A1
class ProductA1 : public AbstractProductA {
public:
    void Show() {
        cout << "ProductA1 Show" << endl;
    }
};

// 具体产品 A2
class ProductA2 : public AbstractProductA {
public:
    void Show() {
        cout << "ProductA2 Show" << endl;
    }
};

// 抽象产品 B
class AbstractProductB {
public:
    virtual void Show() = 0;
};

// 具体产品 B1
class ProductB1 : public AbstractProductB {
public:
    void Show() {
        cout << "ProductB1 Show" << endl;
    }
};

// 具体产品 B2
class ProductB2 : public AbstractProductB {
public:
    void Show() {
        cout << "ProductB2 Show" << endl;
    }
};

// 抽象工厂
class AbstractFactory {
public:
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
};

// 具体工厂 1
class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* CreateProductA() {
        return new ProductA1();
    }

    AbstractProductB* CreateProductB() {
        return new ProductB1();
    }
};

// 具体工厂 2
class ConcreteFactory2 : public AbstractFactory {
public:
    AbstractProductA* CreateProductA() {
        return new ProductA2();
    }

    AbstractProductB* CreateProductB() {
        return new ProductB2();
    }
};

int main() {
    AbstractFactory* factory = new ConcreteFactory1();
    AbstractProductA* productA = factory->CreateProductA();
    AbstractProductB* productB = factory->CreateProductB();

    productA->Show();
    productB->Show();

    delete productA;
    delete productB;

    factory = new ConcreteFactory2();
    productA = factory->CreateProductA();
    productB = factory->CreateProductB();

    productA->Show();
    productB->Show();

    delete productA;
    delete productB;

    delete factory;

    return 0;
}