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

简单工厂模式（Simple Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的最佳方式。在简单工厂模式中，我们创建了一个工厂类，该工厂类负责创建其他类的对象，而不是使用 new 操作符直接实例化对象。这种方法将类的实例化过程从客户端代码中分离出来，使客户端代码与实例化过程解耦。下面是一个简单的 C++ 实现示例：

#include <iostream>
using namespace std;

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

// 具体产品类 A
class ProductA : public Product {
public:
    void use() {
        cout << "Product A used." << endl;
    }
};

// 具体产品类 B
class ProductB : public Product {
public:
    void use() {
        cout << "Product B used." << endl;
    }
};

// 工厂类
class Factory {
public:
    static Product* createProduct(int type) {
        switch (type) {
            case 1:
                return new ProductA();
            case 2:
                return new ProductB();
            default:
                return NULL;
        }
    }
};

int main() {
    Product* productA = Factory::createProduct(1);
    Product* productB = Factory::createProduct(2);
    productA->use();   // Product A used.
    productB->use();   // Product B used.
    delete productA;
    delete productB;
    return 0;
}

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一种创建相关或依赖对象族的最佳方式，而无需指定它们的具体类。在抽象工厂模式中，我们创建了一个抽象工厂类，该工厂类负责创建一组相关对象，例如各种形状的按钮和文本框，而不是使用 new 操作符直接实例化对象。这种方法将类的实例化过程从客户端代码中分离出来，使客户端代码与实例化过程解耦。下面是一个简单的 C++ 实现示例：

#include <iostream>
using namespace std;

// 抽象产品类 A
class ProductA {
public:
    virtual void use() = 0;
};

// 具体产品类 A1
class ProductA1 : public ProductA {
public:
    void use() {
        cout << "Product A1 used." << endl;
    }
};

// 具体产品类 A2
class ProductA2 : public ProductA {
public:
    void use() {
        cout << "Product A2 used." << endl;
    }
};

// 抽象产品类 B
class ProductB {
public:
    virtual void use() = 0;
};

// 具体产品类 B1
class ProductB1 : public ProductB {
public:
    void use() {
        cout << "Product B1 used." << endl;
    }
};

// 具体产品类 B2
class ProductB2 : public ProductB {
public:
    void use() {
        cout << "Product B2 used." << endl;
    }
};

// 抽象工厂类
class Factory {
public:
    virtual ProductA* createProductA() = 0;
    virtual ProductB* createProductB() = 0;
};

// 具体工厂类 1
class Factory1 : public Factory {
public:
    ProductA* createProductA() {
        return new ProductA1();
    }
    ProductB* createProductB() {
        return new ProductB1();
    }
};

// 具体工厂类 2
class Factory2 : public Factory {
public:
    ProductA* createProductA() {
        return new ProductA2();
    }
    ProductB* createProductB() {
        return new ProductB2();
    }
};

int main() {
    Factory* factory1 = new Factory1();
    Factory* factory2 = new Factory2();
    ProductA* productA1 = factory1->createProductA();
    ProductB* productB1 = factory1->createProductB();
    ProductA* productA2 = factory2->createProductA();
    ProductB* productB2 = factory2->createProductB();
    productA1->use();   // Product A1 used.
    productB1->use();   // Product B1 used.
    productA2->use();   // Product A2 used.
    productB2->use();   // Product B2 used.
    delete productA1;
    delete productB1;
    delete productA2;
    delete productB2;
    delete factory1;
    delete factory2;
    return 0;
}