C++中的工厂方法模式

目录

工厂方法模式（Factory Method Pattern）

实际应用

图形创建器（Graphic Creator）

数据库连接器（Database Connector）

文档处理器（Document Processor）

总结

---

工厂方法模式（Factory Method Pattern）

工厂方法模式是一种创建型设计模式，它定义了一个创建对象的接口，但由子类决定实例化哪个类。工厂方法使得一个类的实例化延迟到其子类。

实际应用

1. 当一个类不知道它所需要的对象的确切类型时。
2. 当一个类希望由其子类来指定创建对象时。
3. 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者的信息局部化时。

图形创建器（Graphic Creator）

在图形应用程序中，不同类型的图形（例如：圆形、方形、三角形）需要由特定的创建器类来创建。

#include <iostream>
#include <memory>

// 产品接口
class Shape {
public:
    virtual void draw() = 0;
    virtual ~Shape() = default;
};

// 具体产品：圆形
class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Circle" << std::endl;
    }
};

// 具体产品：方形
class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Square" << std::endl;
    }
};

// 具体产品：三角形
class Triangle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Triangle" << std::endl;
    }
};

// 创建者基类
class ShapeCreator {
public:
    virtual std::unique_ptr<Shape> createShape() = 0;
    virtual ~ShapeCreator() = default;
};

// 具体创建者：圆形创建器
class CircleCreator : public ShapeCreator {
public:
    std::unique_ptr<Shape> createShape() override {
        return std::make_unique<Circle>();
    }
};

// 具体创建者：方形创建器
class SquareCreator : public ShapeCreator {
public:
    std::unique_ptr<Shape> createShape() override {
        return std::make_unique<Square>();
    }
};

// 具体创建者：三角形创建器
class TriangleCreator : public ShapeCreator {
public:
    std::unique_ptr<Shape> createShape() override {
        return std::make_unique<Triangle>();
    }
};

int main() {
    std::unique_ptr<ShapeCreator> creator = std::make_unique<CircleCreator>();
    std::unique_ptr<Shape> shape = creator->createShape();
    shape->draw();

    creator = std::make_unique<SquareCreator>();
    shape = creator->createShape();
    shape->draw();

    creator = std::make_unique<TriangleCreator>();
    shape = creator->createShape();
    shape->draw();

    return 0;
}

数据库连接器（Database Connector）

在数据库应用程序中，不同类型的数据库（例如：MySQL、PostgreSQL、SQLite）需要由特定的创建器类来创建连接对象。

#include <iostream>
#include <memory>

// 产品接口
class DatabaseConnection {
public:
    virtual void connect() = 0;
    virtual ~DatabaseConnection() = default;
};

// 具体产品：MySQL连接
class MySQLConnection : public DatabaseConnection {
public:
    void connect() override {
        std::cout << "Connecting to MySQL Database" << std::endl;
    }
};

// 具体产品：PostgreSQL连接
class PostgreSQLConnection : public DatabaseConnection {
public:
    void connect() override {
        std::cout << "Connecting to PostgreSQL Database" << std::endl;
    }
};

// 具体产品：SQLite连接
class SQLiteConnection : public DatabaseConnection {
public:
    void connect() override {
        std::cout << "Connecting to SQLite Database" << std::endl;
    }
};

// 创建者基类
class DatabaseConnectionCreator {
public:
    virtual std::unique_ptr<DatabaseConnection> createConnection() = 0;
    virtual ~DatabaseConnectionCreator() = default;
};

// 具体创建者：MySQL连接创建器
class MySQLConnectionCreator : public DatabaseConnectionCreator {
public:
    std::unique_ptr<DatabaseConnection> createConnection() override {
        return std::make_unique<MySQLConnection>();
    }
};

// 具体创建者：PostgreSQL连接创建器
class PostgreSQLConnectionCreator : public DatabaseConnectionCreator {
public:
    std::unique_ptr<DatabaseConnection> createConnection() override {
        return std::make_unique<PostgreSQLConnection>();
    }
};

// 具体创建者：SQLite连接创建器
class SQLiteConnectionCreator : public DatabaseConnectionCreator {
public:
    std::unique_ptr<DatabaseConnection> createConnection() override {
        return std::make_unique<SQLiteConnection>();
    }
};

int main() {
    std::unique_ptr<DatabaseConnectionCreator> creator = std::make_unique<MySQLConnectionCreator>();
    std::unique_ptr<DatabaseConnection> connection = creator->createConnection();
    connection->connect();

    creator = std::make_unique<PostgreSQLConnectionCreator>();
    connection = creator->createConnection();
    connection->connect();

    creator = std::make_unique<SQLiteConnectionCreator>();
    connection = creator->createConnection();
    connection->connect();

    return 0;
}

文档处理器（Document Processor）

在文档处理应用程序中，不同类型的文档（例如：Word文档、PDF文档、HTML文档）需要由特定的创建器类来创建文档对象。

#include <iostream>
#include <memory>

// 产品接口
class Document {
public:
    virtual void open() = 0;
    virtual ~Document() = default;
};

// 具体产品：Word文档
class WordDocument : public Document {
public:
    void open() override {
        std::cout << "Opening Word Document" << std::endl;
    }
};

// 具体产品：PDF文档
class PDFDocument : public Document {
public:
    void open() override {
        std::cout << "Opening PDF Document" << std::endl;
    }
};

// 具体产品：HTML文档
class HTMLDocument : public Document {
public:
    void open() override {
        std::cout << "Opening HTML Document" << std::endl;
    }
};

// 创建者基类
class DocumentCreator {
public:
    virtual std::unique_ptr<Document> createDocument() = 0;
    virtual ~DocumentCreator() = default;
};

// 具体创建者：Word文档创建器
class WordDocumentCreator : public DocumentCreator {
public:
    std::unique_ptr<Document> createDocument() override {
        return std::make_unique<WordDocument>();
    }
};

// 具体创建者：PDF文档创建器
class PDFDocumentCreator : public DocumentCreator {
public:
    std::unique_ptr<Document> createDocument() override {
        return std::make_unique<PDFDocument>();
    }
};

// 具体创建者：HTML文档创建器
class HTMLDocumentCreator : public DocumentCreator {
public:
    std::unique_ptr<Document> createDocument() override {
        return std::make_unique<HTMLDocument>();
    }
};

int main() {
    std::unique_ptr<DocumentCreator> creator = std::make_unique<WordDocumentCreator>();
    std::unique_ptr<Document> document = creator->createDocument();
    document->open();

    creator = std::make_unique<PDFDocumentCreator>();
    document = creator->createDocument();
    document->open();

    creator = std::make_unique<HTMLDocumentCreator>();
    document = creator->createDocument();
    document->open();

    return 0;
}

总结

工厂方法模式通过定义一个创建对象的接口，将对象的实际创建工作推迟到子类中实现，从而实现了解耦和扩展性。这种模式在我们实际的项目开发中特别适用于需要创建不同类型对象的场景。