C++工厂方法之对象创建型模式详解

什么是对象创建型模式

对象创建型模式是指通过专门定义的工厂方法来创建对象，并且将对象的创建延迟到子类中去实现。

对象创建型模式实现了解耦，即将构造运算与对象的使用分离开来，使得相同的构造过程可以创建不同的产品。

工厂方法模式

工厂方法模式（Factory Method）是对象创建型模式的一种，通过定义工厂接口和工厂的具体实现来创建产品。

工厂方法模式解决了简单工厂模式的缺点，可以在工厂接口和工厂实现类上进行扩展，从而提高系统的灵活性。

下面以一个简单的汽车工厂为例说明工厂方法模式的具体实现：

class Car {
public:
    virtual void drive() = 0;
};

class BenzCar : public Car {
public:
    void drive() {
        std::cout << "BenzCar is driving." << std::endl;
    }
};

class BMWCar : public Car {
public:
    void drive() {
        std::cout << "BMWCar is driving." << std::endl;
    }
};

class CarFactory {
public:
    virtual Car* createCar() = 0;
};

class BenzFactory : public CarFactory {
public:
    Car* createCar() {
        return new BenzCar();
    }
};

class BMWFactory : public CarFactory {
public:
    Car* createCar() {
        return new BMWCar();
    }
};

这个例子中，Car 是产品基类，BenzCar 和 BMWCar 是具体的产品类，CarFactory 是工厂基类，BenzFactory 和 BMWFactory 是具体的工厂类。

对象池模式

对象池模式（Object Pool）是一种预先创建一定数量的对象，并对外提供访问接口的一种模式。

对象池可以避免频繁的创建对象和销毁对象，从而提高程序的性能。

下面以一个简单的线程池为例说明对象池的具体实现：

class ThreadPool {
public:
    ThreadPool(int size) {
        m_freeWorkers.resize(size);
        for (int i = 0; i < size; i++) {
            m_freeWorkers[i] = new Worker();
        }
    }

    void addTask(Task* task) {
        std::unique_lock<std::mutex> lock(m_mutex);
        while (m_queue.size() >= m_freeWorkers.size()) {
            m_cond.wait(lock);
        }
        m_queue.push(task);
        m_cond.notify_one();
    }

    void stop() {
        m_isStopped = true;
        m_cond.notify_all();
        for (auto worker : m_freeWorkers) {
            worker->stop();
        }
        for (auto worker : m_busyWorkers) {
            worker->stop();
        }
    }

private:
    class Worker {
    public:
        void operator()() {
            while (!m_isStopped) {
                Task* task = nullptr;
                {
                    std::unique_lock<std::mutex> lock(m_mutex);
                    while (m_queue.empty() && !m_isStopped) {
                        m_cond.wait(lock);
                    }
                    if (m_isStopped) {
                        break;
                    }
                    task = m_queue.front();
                    m_queue.pop();
                }
                task->run();
            }
        }

        void stop() {
            m_isStopped = true;
            m_cond.notify_one();
        }

    private:
        std::mutex m_mutex;
        std::condition_variable m_cond;
        std::queue<Task*> m_queue;
        bool m_isStopped = false;
    };

    std::mutex m_mutex;
    std::condition_variable m_cond;
    std::queue<Task*> m_queue;
    std::vector<Worker*> m_freeWorkers;
    std::vector<Worker*> m_busyWorkers;
    bool m_isStopped = false;
};

在这个例子中，我们使用了 ThreadPool 类来管理线程池，其中 Worker 类表示一个工作线程。

线程池在初始化时预先创建了一定数量的工作线程，并将它们保存在 m_freeWorkers 中。当需要执行任务时，从 m_freeWorkers 中取出一个空闲的工作线程执行任务，如果没有空闲的工作线程，则阻塞等待直到有空闲的工作线程。

当线程池停止时，则调用所有工作线程的 stop 方法通知它们停止工作。

总结

对象创建型模式是一种常用的设计模式，它通过专门定义的工厂方法来创建对象，将对象的创建延迟到子类中去实现，从而提高系统的灵活性和可维护性。

工厂方法模式是对象创建型模式的一种，通过定义工厂接口和工厂的具体实现来创建产品。对象池模式是一种预先创建一定数量的对象，并对外提供访问接口的一种模式，可以避免频繁的创建对象和销毁对象，从而提高程序的性能。