c++ 11 新特性 不同数据类型之间转换函数之reinterpret_cast

就像一个工厂不断地生产零件一样，把创建对象的流程集中封装在一个工厂类中，这就是简单工厂模式，属于创建型设计模式。

抽象产品类，即Shape，描述产品的通用行为。接着具体产品类可以继承自Shape，例如Circle或者Square。再由工厂类ShapeFactory 的创造方法createShape里的if-else逻辑返回具体产品类。

这样做的好处就是，客户端没有必要访问具体的产品类，而是只通过访问工厂类，调用工厂方法来获取具体产品，从而降低了耦合。但是如果需要添加新的产品，就需要修改工厂类的代码。

为了解决该问题，我们可以在简单工厂模式的基础之上，对工厂这个概念再做一个抽象，引入抽象工厂和具体工厂的概念，从而添加新的产品只需要添加新的工厂类而无需修改原来的代码。这样就使得产品的生产更加灵活，支持扩展，符合开闭原则。符合这种核心设计思想的设计模式就是工厂方法模式。

Java代码：

// 抽象产品
interface Shape {
    void draw();
}

// 具体产品-圆形
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Circle");
    }
}

// 具体产品-正方形
class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Square");
    }
}

// 抽象工厂
interface ShapeFactory {
    Shape createShape();
}

// 具体工厂-创建圆形
class CircleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}


// 具体工厂-创建正方形
class SquareFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Square();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.creaeteShape();
        circle.draw();    // 输出：Circle

        ShapeFactory squareFactory = new SquareFactory();
        Shape square = squareFactory.createShape();
        square.draw();    // 输出：Square
    }
}

总结一下，什么时候使用工厂方法模式：当创建对象涉及一系列复杂的初始化逻辑，而且这些逻辑在不同的子类中可能有所不同时，可以用工厂方法模式将这些初始化逻辑封装在子类的工厂中。

工厂模式的应用：Spring框架中的Bean工厂：通过配置文件或注解，Spring可以根据配置信息动态地创建和管理对象；JDBC中的Connection工厂：在Java数据库连接中，DriverManager使用工厂方法模式来创建数据库连接。不同的数据库驱动（如MySQL、PostgreSQL等）都有对应的工厂来创建连接。

【设计模式专题之工厂方法模式】2.积木工厂

CPP代码题解：

#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;
}