C++学习笔记--工厂模式

工厂模式是一种创建型设计模式，它的主要目的是隐藏对象的创建过程，将对象的创建和使用分离开来。这样可以在不改变现有代码的情况下添加新的产品类，并且可以通过对工厂类进行修改来改变对象的创建过程。

工厂模式主要由三个角色组成：

抽象产品类：定义产品的共性，可以是一个抽象类或接口。

具体产品类：实现抽象产品类定义的接口，由工厂类创建，每个具体产品类都对应一个具体工厂类。

工厂类：创建产品对象的工厂，它包含一个创建产品的方法，该方法可以根据传入的参数来创建不同的产品对象。工厂类可以是抽象类或接口，也可以是一个普通类。

工厂模式有两种常见的实现方式：简单工厂模式和工厂方法模式。

简单工厂模式：简单工厂模式是通过一个工厂类来创建所有的产品对象。工厂类通常包含一个静态方法，根据传入的参数来决定创建哪种产品对象。简单工厂模式的优点是实现简单，但缺点是工厂类负责创建所有的产品对象，如果产品类型过多，会导致工厂类过于庞大，难以维护。

工厂方法模式：工厂方法模式是将工厂类抽象出来，每个具体产品类都对应一个具体工厂类，工厂类负责创建与之对应的产品对象。工厂方法模式的优点是可以支持扩展，每个产品类都有一个与之对应的工厂类，新产品的加入不会影响已有产品的代码。缺点是需要创建很多的工厂类。

下面是一个简单工厂模式的示例代码：

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

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

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

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

int main() {
    Product* product1 = Factory::createProduct(1);
    product1->use(); // 输出 "ConcreteProduct1 used."

    Product* product2 = Factory::createProduct(2);
    product2->use(); // 输出 "ConcreteProduct2 used."

    return 0;
}
 

工厂方法模式是一种创建型设计模式，它提供了一个接口来创建对象，但是允许子类决定要实例化的类。在工厂方法模式中，创建对象的代码被封装在一个工厂接口中，具体对象的创建被子类实现。这样就能在不修改客户端代码的情况下添加新的产品类型。

工厂方法模式通常包含以下角色：

抽象产品：定义产品的接口，所有具体产品都实现这个接口。
具体产品：实现抽象产品接口，定义具体产品的行为。
抽象工厂：定义创建产品的接口，包含一个或多个工厂方法，用于创建不同类型的产品。
具体工厂：实现抽象工厂接口，包含一个或多个工厂方法，用于创建具体产品的实例。
工厂方法模式的优点是：

可以隐藏产品的创建细节，使客户端代码更加简洁和易于维护。
增加新的产品类型时，只需要添加具体产品和相应的具体工厂类，不需要修改已有的代码，符合开闭原则。
可以将具体产品的创建过程推迟到子类中，实现了抽象工厂模式中的产品族概念。
一个简单的工厂方法模式示例代码如下：

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

// 具体产品A
class ConcreteProductA : public Product {
public:
    void operation() override {
        cout << "I'm a ConcreteProductA" << endl;
    }
};

// 具体产品B
class ConcreteProductB : public Product {
public:
    void operation() override {
        cout << "I'm a ConcreteProductB" << endl;
    }
};

// 抽象工厂
class Factory {
public:
    virtual ~Factory() {}
    virtual Product* createProduct() = 0;
};

// 具体工厂A
class ConcreteFactoryA : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
};

// 具体工厂B
class ConcreteFactoryB : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProductB();
    }
};

// 客户端
int main() {
    Factory* factoryA = new ConcreteFactoryA();
    Product* productA = factoryA->createProduct();
    productA->operation(); // 输出: I'm a ConcreteProductA

    Factory* factoryB = new ConcreteFactoryB();
    Product* productB = factoryB->createProduct();
    productB->operation(); // 输出: I'm a ConcreteProductB

    delete factoryA;
    delete productA;
    delete factoryB;
    delete productB;
    return 0;
}