
C++ 工厂方法模式讲解和代码示例
工厂方法是一种创建型设计模式, 解决了在不指定具体类的情况下创建产品对象的问题。
工厂方法定义了一个方法, 且必须使用该方法代替通过直接调用构造函数来创建对象 ( new
操作符) 的方式。 子类可重写该方法来更改将被创建的对象所属类。
如果你不清楚工厂、 工厂方法和抽象工厂模式之间的区别, 请参阅工厂模式比较。
复杂度:
流行度:
使用示例: 工厂方法模式在 C++ 代码中得到了广泛使用。 当你需要在代码中提供高层次的灵活性时, 该模式会非常实用。
识别方法: 工厂方法可通过构建方法来识别, 它会创建具体类的对象, 但以抽象类型或接口的形式返回这些对象。
概念示例
本例说明了工厂方法设计模式的结构并重点回答了下面的问题:
- 它由哪些类组成?
- 这些类扮演了哪些角色?
- 模式中的各个元素会以何种方式相互关联?
main.cc: 概念示例
/** * The Product interface declares the operations that all concrete products must * implement. */ class Product { public: virtual ~Product() {} virtual std::string Operation() const = 0; }; /** * Concrete Products provide various implementations of the Product interface. */ class ConcreteProduct1 : public Product { public: std::string Operation() const override { return "{Result of the ConcreteProduct1}"; } }; class ConcreteProduct2 : public Product { public: std::string Operation() const override { return "{Result of the ConcreteProduct2}"; } }; /** * The Creator class declares the factory method that is supposed to return an * object of a Product class. The Creator's subclasses usually provide the * implementation of this method. */ class Creator { /** * Note that the Creator may also provide some default implementation of the * factory method. */ public: virtual ~Creator(){}; virtual Product* FactoryMethod() const = 0; /** * Also note that, despite its name, the Creator's primary responsibility is * not creating products. Usually, it contains some core business logic that * relies on Product objects, returned by the factory method. Subclasses can * indirectly change that business logic by overriding the factory method and * returning a different type of product from it. */ std::string SomeOperation() const { // Call the factory method to create a Product object. Product* product = this->FactoryMethod(); // Now, use the product. std::string result = "Creator: The same creator's code has just worked with " + product->Operation(); delete product; return result; } }; /** * Concrete Creators override the factory method in order to change the * resulting product's type. */ class ConcreteCreator1 : public Creator { /** * Note that the signature of the method still uses the abstract product type, * even though the concrete product is actually returned from the method. This * way the Creator can stay independent of concrete product classes. */ public: Product* FactoryMethod() const override { return new ConcreteProduct1(); } }; class ConcreteCreator2 : public Creator { public: Product* FactoryMethod() const override { return new ConcreteProduct2(); } }; /** * The client code works with an instance of a concrete creator, albeit through * its base interface. As long as the client keeps working with the creator via * the base interface, you can pass it any creator's subclass. */ void ClientCode(const Creator& creator) { // ... std::cout << "Client: I'm not aware of the creator's class, but it still works.\n" << creator.SomeOperation() << std::endl; // ... } /** * The Application picks a creator's type depending on the configuration or * environment. */ int main() { std::cout << "App: Launched with the ConcreteCreator1.\n"; Creator* creator = new ConcreteCreator1(); ClientCode(*creator); std::cout << std::endl; std::cout << "App: Launched with the ConcreteCreator2.\n"; Creator* creator2 = new ConcreteCreator2(); ClientCode(*creator2); delete creator; delete creator2; return 0; }
Output.txt: 执行结果
App: Launched with the ConcreteCreator1. Client: I'm not aware of the creator's class, but it still works. Creator: The same creator's code has just worked with {Result of the ConcreteProduct1} App: Launched with the ConcreteCreator2. Client: I'm not aware of the creator's class, but it still works. Creator: The same creator's code has just worked with {Result of the ConcreteProduct2}