C++中的抽象工厂模式
目录
抽象工厂模式（Abstract Factory Pattern）
实际应用
跨平台GUI工厂
数据库访问抽象工厂
跨平台文件系统工厂
总结
抽象工厂模式（Abstract Factory Pattern）
抽象工厂模式是一种创建型设计模式，它提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式通过定义多个创建方法，每个方法返回一种抽象产品类型的实例，来实现产品族的创建。
实际应用
1. 当一个系统要独立于它的产品的创建、组合和表示时。
2. 当一个系统要由多个产品系列中的一个来配置时。
3. 当需要提供一个产品类库，而只想显示它们的接口而不是实现时。
跨平台GUI工厂
在跨平台应用程序中，不同平台（例如：Windows、Mac、Linux）有不同的GUI组件。
#include
#include
// 抽象产品：按钮
class Button {
public:
virtual void paint() = 0;
virtual ~Button() = default;
};
// 具体产品：Windows按钮
class WindowsButton : public Button {
public:
void paint() override {
std::cout << "Painting Windows Button" << std::endl;
}
};
// 具体产品：Mac按钮
class MacButton : public Button {
public:
void paint() override {
std::cout << "Painting Mac Button" << std::endl;
}
};
// 抽象产品：文本框
class TextBox {
public:
virtual void draw() = 0;
virtual ~TextBox() = default;
};
// 具体产品：Windows文本框
class WindowsTextBox : public TextBox {
public:
void draw() override {
std::cout << "Drawing Windows TextBox" << std::endl;
}
};
// 具体产品：Mac文本框
class MacTextBox : public TextBox {
public:
void draw() override {
std::cout << "Drawing Mac TextBox" << std::endl;
}
};
// 抽象工厂
class GUIFactory {
public:
virtual std::unique_ptr数据库访问抽象工厂
在企业应用中，不同的数据库（例如：MySQL、PostgreSQL、SQLite）需要由特定的工厂来创建相应的连接和命令对象。
#include
#include
// 抽象产品：数据库连接
class DBConnection {
public:
virtual void connect() = 0;
virtual ~DBConnection() = default;
};
// 具体产品：MySQL连接
class MySQLConnection : public DBConnection {
public:
void connect() override {
std::cout << "Connecting to MySQL Database" << std::endl;
}
};
// 具体产品：PostgreSQL连接
class PostgreSQLConnection : public DBConnection {
public:
void connect() override {
std::cout << "Connecting to PostgreSQL Database" << std::endl;
}
};
// 抽象产品：数据库命令
class DBCommand {
public:
virtual void execute() = 0;
virtual ~DBCommand() = default;
};
// 具体产品：MySQL命令
class MySQLCommand : public DBCommand {
public:
void execute() override {
std::cout << "Executing MySQL Command" << std::endl;
}
};
// 具体产品：PostgreSQL命令
class PostgreSQLCommand : public DBCommand {
public:
void execute() override {
std::cout << "Executing PostgreSQL Command" << std::endl;
}
};
// 抽象工厂
class DBFactory {
public:
virtual std::unique_ptr createConnection() = 0;
virtual std::unique_ptr createCommand() = 0;
virtual ~DBFactory() = default;
};
// 具体工厂：MySQL工厂
class MySQLFactory : public DBFactory {
public:
std::unique_ptr createConnection() override {
return std::make_unique();
}
std::unique_ptr createCommand() override {
return std::make_unique();
}
};
// 具体工厂：PostgreSQL工厂
class PostgreSQLFactory : public DBFactory {
public:
std::unique_ptr createConnection() override {
return std::make_unique();
}
std::unique_ptr createCommand() override {
return std::make_unique();
}
};
void clientCode(DBFactory& factory) {
auto connection = factory.createConnection();
auto command = factory.createCommand();
connection->connect();
command->execute();
}
int main() {
std::unique_ptr factory = std::make_unique();
clientCode(*factory);
factory = std::make_unique();
clientCode(*factory);
return 0;
}
跨平台文件系统工厂
在跨平台文件系统应用程序中，不同平台（例如：Windows、Linux、Mac）有不同的文件系统操作。
#include
#include
// 抽象产品：文件
class File {
public:
virtual void open() = 0;
virtual ~File() = default;
};
// 具体产品：Windows文件
class WindowsFile : public File {
public:
void open() override {
std::cout << "Opening Windows File" << std::endl;
}
};
// 具体产品：Linux文件
class LinuxFile : public File {
public:
void open() override {
std::cout << "Opening Linux File" << std::endl;
}
};
// 抽象产品：目录
class Directory {
public:
virtual void list() = 0;
virtual ~Directory() = default;
};
// 具体产品：Windows目录
class WindowsDirectory : public Directory {
public:
void list() override {
std::cout << "Listing Windows Directory" << std::endl;
}
};
// 具体产品：Linux目录
class LinuxDirectory : public Directory {
public:
void list() override {
std::cout << "Listing Linux Directory" << std::endl;
}
};
// 抽象工厂
class FileSystemFactory {
public:
virtual std::unique_ptr createFile() = 0;
virtual std::unique_ptr createDirectory() = 0;
virtual ~FileSystemFactory() = default;
};
// 具体工厂：Windows文件系统工厂
class WindowsFileSystemFactory : public FileSystemFactory {
public:
std::unique_ptr createFile() override {
return std::make_unique();
}
std::unique_ptr createDirectory() override {
return std::make_unique();
}
};
// 具体工厂：Linux文件系统工厂
class LinuxFileSystemFactory : public FileSystemFactory {
public:
std::unique_ptr createFile() override {
return std::make_unique();
}
std::unique_ptr createDirectory() override {
return std::make_unique();
}
};
void clientCode(FileSystemFactory& factory) {
auto file = factory.createFile();
auto directory = factory.createDirectory();
file->open();
directory->list();
}
int main() {
std::unique_ptr factory = std::make_unique();
clientCode(*factory);
factory = std::make_unique();
clientCode(*factory);
return 0;
}
总结
抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。这个模式有助于提高系统的可扩展性和灵活性，使得系统能够在不同环境下使用不同的实现。
