学校网站建设维护投标方案,郑州注册公司代理记账,漳州网站开发点博大a优,百度seo效果《设计模式》工厂模式
工厂模式又分为简单工厂#xff08;Simple Factory#xff09;、工厂方法#xff08;Factory Method#xff09;和抽象工厂#xff08;Abstract Factory#xff09;都是常用的创建型设计模式#xff0c;它们的主要区别如下#xff1a;
简单工厂…《设计模式》工厂模式
工厂模式又分为简单工厂Simple Factory、工厂方法Factory Method和抽象工厂Abstract Factory都是常用的创建型设计模式它们的主要区别如下
简单工厂由一个工厂类根据传入的参数来决定创建哪一种产品类的对象。简单工厂适用于对象的创建比较简单且客户端只需要知道传入的参数即可获取相应的对象的场景。工厂方法定义一个用于创建对象的接口让子类决定实例化哪一个类。工厂方法模式适用于需要一组相关对象的场景客户端不需要知道它所使用的对象的具体类型只需要知道创建对象的接口即可。抽象工厂提供一个创建一系列相关或相互依赖对象的接口而无需指定它们的具体类。抽象工厂模式适用于需要一组相关的对象这些对象之间有相互依赖关系客户端不需要知道创建对象的具体实现细节只需要知道创建对象的接口即可。
这三种工厂模式的优点及使用场景如下
简单工厂的优点易于实现、客户端调用方便。适用于工厂类负责创建的对象比较少的场景。工厂方法的优点符合开闭原则、可扩展性强。适用于需要一组相关对象并且需要灵活地增加、替换和删除对象的场景。抽象工厂的优点符合开闭原则、封装性好、可扩展性强。适用于需要创建一组相互依赖、相关或不同类型的对象的场景。
综上所述选择哪种工厂模式取决于具体的需求场景。如果只需要创建一种对象则可以使用简单工厂如果需要创建一组相关的对象并且需要灵活地增加、替换和删除对象则可以使用工厂方法如果需要创建一组相互依赖、相关或不同类型的对象则可以使用抽象工厂。
简单工厂
首先定义一个抽象产品类 Product它是由简单工厂模式负责创建的对象
class Product {
public:virtual ~Product() {}virtual void operation() 0;
};接下来定义具体产品类 ConcreteProductA 和 ConcreteProductB
class ConcreteProductA : public Product {
public:void operation() {std::cout ConcreteProductA::operation() std::endl;}
};class ConcreteProductB : public Product {
public:void operation() {std::cout ConcreteProductB::operation() std::endl;}
};这两个类继承了抽象产品类 Product并实现了 operation 函数。ConcreteProductA 和 ConcreteProductB 是简单工厂模式创建的具体对象。
接下来定义一个工厂类 Factory它负责创建具体产品的对象
class Factory {
public:Product* create_product(int type) {switch (type) {case 0:return new ConcreteProductA();case 1:return new ConcreteProductB();default:return nullptr;}}
};这个工厂类有一个 create_product 函数根据传入的类型返回具体产品的对象。在这个示例中我们使用 switch 语句根据类型选择创建哪种具体产品。
最后我们可以在主函数中使用简单工厂模式创建具体产品的对象
int main() {Factory factory;Product* productA factory.create_product(0);if (productA) {productA-operation();delete productA;}Product* productB factory.create_product(1);if (productB) {productB-operation();delete productB;}Product* productC factory.create_product(2);if (!productC) {std::cout Invalid product type! std::endl;}return 0;
}在主函数中我们先创建一个工厂对象然后分别使用它创建 ConcreteProductA 和 ConcreteProductB 的对象并调用它们的 operation 函数进行操作。最后我们试图使用一个不存在的类型创建产品这时候工厂类将返回 nullptr。
以上就是用 C 实现简单工厂模式的示例。
工厂方法
首先定义一个抽象产品类 Product它是由工厂方法模式负责创建的对象
class Product {
public:virtual ~Product() {}virtual void operation() 0;
};接下来定义具体产品类 ConcreteProductA 和 ConcreteProductB
class ConcreteProductA : public Product {
public:void operation() {std::cout ConcreteProductA::operation() std::endl;}
};class ConcreteProductB : public Product {
public:void operation() {std::cout ConcreteProductB::operation() std::endl;}
};这两个类继承了抽象产品类 Product并实现了 operation 函数。ConcreteProductA 和 ConcreteProductB 是工厂方法模式创建的具体对象。
接下来定义一个抽象工厂类 Factory它声明一个工厂方法 create_product由具体工厂类负责实现这个方法
class Factory {
public:virtual ~Factory() {}virtual Product* create_product() 0;
};具体工厂类继承这个抽象工厂类并实现 create_product 方法用于创建具体产品的对象
class ConcreteFactoryA : public Factory {
public:Product* create_product() {return new ConcreteProductA();}
};class ConcreteFactoryB : public Factory {
public:Product* create_product() {return new ConcreteProductB();}
};这两个类继承了抽象工厂类 Factory并实现了 create_product 方法。ConcreteFactoryA 和 ConcreteFactoryB 是工厂方法模式创建的具体工厂。
最后我们可以在主函数中使用工厂方法模式创建具体产品的对象
int main() {Factory* factoryA new ConcreteFactoryA();Product* productA factoryA-create_product();if (productA) {productA-operation();delete productA;}delete factoryA;Factory* factoryB new ConcreteFactoryB();Product* productB factoryB-create_product();if (productB) {productB-operation();delete productB;}delete factoryB;return 0;
}在主函数中我们先创建一个 ConcreteFactoryA 对象然后使用它创建 ConcreteProductA 的对象并调用它的 operation 函数进行操作。然后我们创建一个 ConcreteFactoryB 对象使用它创建 ConcreteProductB 的对象并调用它的 operation 函数进行操作。最后我们删除创建的对象并销毁工厂对象。
以上就是用 C 实现工厂方法模式的示例。
抽象工厂
首先定义一个抽象产品类 AbstractProductA 和 AbstractProductB它们是由抽象工厂模式负责创建的对象
class AbstractProductA {
public:virtual ~AbstractProductA() {}virtual void operationA() 0;
};class AbstractProductB {
public:virtual ~AbstractProductB() {}virtual void operationB() 0;
};接下来定义具体产品类 ConcreteProductA1、ConcreteProductA2、ConcreteProductB1 和 ConcreteProductB2
class ConcreteProductA1 : public AbstractProductA {
public:void operationA() {std::cout ConcreteProductA1::operationA() std::endl;}
};class ConcreteProductA2 : public AbstractProductA {
public:void operationA() {std::cout ConcreteProductA2::operationA() std::endl;}
};class ConcreteProductB1 : public AbstractProductB {
public:void operationB() {std::cout ConcreteProductB1::operationB() std::endl;}
};class ConcreteProductB2 : public AbstractProductB {
public:void operationB() {std::cout ConcreteProductB2::operationB() std::endl;}
};这四个类继承了抽象产品类 AbstractProductA 和 AbstractProductB并实现了 operationA 和 operationB 函数。ConcreteProductA1、ConcreteProductA2、ConcreteProductB1 和 ConcreteProductB2 是抽象工厂模式创建的具体对象。
接下来定义一个抽象工厂类 AbstractFactory它声明一组工厂方法 createProductA 和 createProductB由具体工厂类负责实现这些方法
class AbstractFactory {
public:virtual ~AbstractFactory() {}virtual AbstractProductA* createProductA() 0;virtual AbstractProductB* createProductB() 0;
};具体工厂类继承这个抽象工厂类并实现 createProductA 和 createProductB 方法用于创建具体产品的对象
class ConcreteFactory1 : public AbstractFactory {
public:AbstractProductA* createProductA() {return new ConcreteProductA1();}AbstractProductB* createProductB() {return new ConcreteProductB1();}
};class ConcreteFactory2 : public AbstractFactory {
public:AbstractProductA* createProductA() {return new ConcreteProductA2();}AbstractProductB* createProductB() {return new ConcreteProductB2();}
};这两个类继承了抽象工厂类 AbstractFactory并实现了 createProductA 和 createProductB 方法。ConcreteFactory1 和 ConcreteFactory2 是抽象工厂模式创建的具体工厂。
最后我们可以在主函数中使用抽象工厂模式创建具体产品的对象
int main() {// 使用具体工厂1创建产品AbstractFactory* factory1 new ConcreteFactory1();AbstractProductA* productA1 factory1-createProductA();AbstractProductB* productB1 factory1-createProductB();productA1-operationA();productB1-operationB();// 使用具体工厂2创建产品AbstractFactory* factory2 new ConcreteFactory2();AbstractProductA* productA2 factory2-createProductA();AbstractProductB* productB2 factory2-createProductB();productA2-operationA();productB2-operationB();// 释放内存delete productA1;delete productB1;delete factory1;delete productA2;delete productB2;delete factory2;return 0;
}运行结果如下
ConcreteProductA1::operationA()
ConcreteProductB1::operationB()
ConcreteProductA2::operationA()
ConcreteProductB2::operationB()这个示例实现了一个抽象工厂模式其中抽象工厂类 AbstractFactory 声明了一组工厂方法具体工厂类 ConcreteFactory1 和 ConcreteFactory2 实现了这些方法用于创建具体产品的对象。而具体产品类 ConcreteProductA1、ConcreteProductA2、ConcreteProductB1 和 ConcreteProductB2 继承了抽象产品类 AbstractProductA 和 AbstractProductB并实现了 operationA 和 operationB 函数表示具体产品的操作。
以上就是用 C 实现抽象工厂模式的示例。
抽象工厂模式适用于需要一次性创建一系列相关或相互依赖的对象时它能够提供一个简单的接口用于创建这些对象同时保证这些对象是相互兼容的。由于该模式要求所有具体产品都必须实现相同的接口因此它提供了更好的灵活性和可扩展性。
