设计模式：简单工厂、工厂方法、抽象工厂的区别

设计模式：简单工厂、工厂方法、抽象工厂的区别

简单工厂模式（Simple Factory Pattern）

描述：
简单工厂模式并不是严格意义上的设计模式，而更像是一种编程习惯或者说是一种创建对象的简单方式。它使用一个工厂类来创建对象，这个工厂类包含一个方法，根据输入的参数或条件来创建相应的对象实例。

举例：

#include <iostream>
#include <memory>

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

// 具体产品类 A
class ConcreteProductA : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductA\n";
    }
};

// 具体产品类 B
class ConcreteProductB : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductB\n";
    }
};

// 简单工厂类
class SimpleFactory {
public:
    std::unique_ptr<Product> createProduct(int type) {
        if (type == 1) {
            return std::make_unique<ConcreteProductA>();
        } else if (type == 2) {
            return std::make_unique<ConcreteProductB>();
        } else {
            return nullptr;
        }
    }
};

int main() {
    SimpleFactory factory;

    std::unique_ptr<Product> productA = factory.createProduct(1);
    if (productA)
        productA->use();

    std::unique_ptr<Product> productB = factory.createProduct(2);
    if (productB)
        productB->use();

    return 0;
}

工厂方法模式（Factory Method Pattern）

描述：
工厂方法模式是一种创建型模式，它定义了一个创建对象的接口，但将实际创建工作推迟到子类中。每个子类都可以重写这个工厂方法以返回不同的对象实例。

举例：

#include <iostream>
#include <memory>

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

// 具体产品类 A
class ConcreteProductA : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductA\n";
    }
};

// 具体产品类 B
class ConcreteProductB : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductB\n";
    }
};

// 抽象工厂类
class Factory {
public:
    virtual std::unique_ptr<Product> createProduct() = 0;
    virtual ~Factory() {}
};

// 具体工厂类 A
class ConcreteFactoryA : public Factory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ConcreteProductA>();
    }
};

// 具体工厂类 B
class ConcreteFactoryB : public Factory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ConcreteProductB>();
    }
};

int main() {
    std::unique_ptr<Factory> factoryA = std::make_unique<ConcreteFactoryA>();
    std::unique_ptr<Product> productA = factoryA->createProduct();
    productA->use();

    std::unique_ptr<Factory> factoryB = std::make_unique<ConcreteFactoryB>();
    std::unique_ptr<Product> productB = factoryB->createProduct();
    productB->use();

    return 0;
}

抽象工厂模式（Abstract Factory Pattern）

描述：
抽象工厂模式提供一个接口来创建一系列相关或依赖对象的家族，而不需要指定它们的具体类。它是工厂方法模式的扩展，不仅仅是一个方法，而是一个接口。

举例：

#include <iostream>
#include <memory>

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

// 具体产品类 A1
class ConcreteProductA1 : public AbstractProductA {
public:
    void useA() override {
        std::cout << "Using ConcreteProductA1\n";
    }
};

// 具体产品类 A2
class ConcreteProductA2 : public AbstractProductA {
public:
    void useA() override {
        std::cout << "Using ConcreteProductA2\n";
    }
};

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

// 具体产品类 B1
class ConcreteProductB1 : public AbstractProductB {
public:
    void useB() override {
        std::cout << "Using ConcreteProductB1\n";
    }
};

// 具体产品类 B2
class ConcreteProductB2 : public AbstractProductB {
public:
    void useB() override {
        std::cout << "Using ConcreteProductB2\n";
    }
};

// 抽象工厂类
class AbstractFactory {
public:
    virtual std::unique_ptr<AbstractProductA> createProductA() = 0;
    virtual std::unique_ptr<AbstractProductB> createProductB() = 0;
    virtual ~AbstractFactory() {}
};

// 具体工厂类 1
class ConcreteFactory1 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ConcreteProductA1>();
    }

    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ConcreteProductB1>();
    }
};

// 具体工厂类 2
class ConcreteFactory2 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ConcreteProductA2>();
    }

    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ConcreteProductB2>();
    }
};

int main() {
    std::unique_ptr<AbstractFactory> factory1 = std::make_unique<ConcreteFactory1>();
    std::unique_ptr<AbstractProductA> productA1 = factory1->createProductA();
    std::unique_ptr<AbstractProductB> productB1 = factory1->createProductB();
    productA1->useA();
    productB1->useB();

    std::unique_ptr<AbstractFactory> factory2 = std::make_unique<ConcreteFactory2>();
    std::unique_ptr<AbstractProductA> productA2 = factory2->createProductA();
    std::unique_ptr<AbstractProductB> productB2 = factory2->createProductB();
    productA2->useA();
    productB2->useB();

    return 0;
}