简单工厂模式与工厂模式

简单工厂模式的核心思想 是将产品的创建过程封装在一个工厂类中，把创建对象的流程集中在这个工厂类里面。

简单工厂模式包括三个主要角色，工厂类，抽象产品，具体产品。

抽象产品：描述产品的通用行为。

具体产品：实现抽象产品接口或者继承抽象产品类

工厂类：负责创建产品，根据传递的不同参数创建不同的产品示例。

由于简单工厂模式只有一个工厂类，负责创建所有产品，如果要添加新的产品，通常需要修改工厂类的代码。

工厂方法模式引入抽象工厂和具体工厂的概念，每个具体工厂只负责创建一个具体的产品，添加新的产品只需要添加新的工厂类而无需修改原来的代码，这样就使得产品的生产更加灵活，支持扩展，符合开闭原则。

工厂方法模式分为以下几个角色 ：

抽象工厂：一个接口，包含一个抽象的工厂方法（用于创建产品对象）。

具体工厂：实现抽象工厂接口，创建具体的产品。

抽象产品：定义产品的接口。

具体产品：实现抽象产品接口，是工厂创建的对象。

demo程序：

#include <iostream>
#include <vector>

// 抽象积木接口
class Block {
public:
virtual void produce() = 0;
};

// 具体圆形积木实现
class CircleBlock : public Block {
public:
void produce() override {
std::cout << "Circle Block" << std::endl;
}
};

// 具体方形积木实现
class SquareBlock : public Block {
public:
void produce() override {
std::cout << "Square Block" << std::endl;
}
};

// 抽象积木工厂接口
class BlockFactory {
public:
virtual Block* createBlock() = 0;
};

// 具体圆形积木工厂实现
class CircleBlockFactory : public BlockFactory {
public:
Block* createBlock() override {
return new CircleBlock();
}
};

// 具体方形积木工厂实现
class SquareBlockFactory : public BlockFactory {
public:
Block* createBlock() override {
return new SquareBlock();
}
};

// 积木工厂系统
class BlockFactorySystem {
private:
std::vector<Block*> blocks;

public:
void produceBlocks(BlockFactory* factory, int quantity) {
for (int i = 0; i < quantity; i++) {
Block* block = factory->createBlock();
blocks.push_back(block);
block->produce();
}
}

const std::vector<Block*>& getBlocks() const {
return blocks;
}

~BlockFactorySystem() {
// 释放所有动态分配的积木对象
for (Block* block : blocks) {
delete block;
}
}
};

int main() {
// 创建积木工厂系统
BlockFactorySystem factorySystem;

// 读取生产次数
int productionCount;
std::cin >> productionCount;

// 读取每次生产的积木类型和数量
for (int i = 0; i < productionCount; i++) {
std::string blockType;
int quantity;
std::cin >> blockType >> quantity;

if (blockType == "Circle") {
factorySystem.produceBlocks(new CircleBlockFactory(), quantity);
} else if (blockType == "Square") {
factorySystem.produceBlocks(new SquareBlockFactory(), quantity);
}
}

return 0;
}