微信公众号网站开发语言,wordpress发布文章报错,注册一个公司一年费用,页面模板在公号什么地方显示设计模式#xff1a;简单工厂、工厂方法、抽象工厂的区别
简单工厂模式#xff08;Simple Factory Pattern#xff09;
描述#xff1a; 简单工厂模式并不是严格意义上的设计模式#xff0c;而更像是一种编程习惯或者说是一种创建对象的简单方式。它使用一个工厂类来创建…设计模式简单工厂、工厂方法、抽象工厂的区别
简单工厂模式Simple Factory Pattern
描述 简单工厂模式并不是严格意义上的设计模式而更像是一种编程习惯或者说是一种创建对象的简单方式。它使用一个工厂类来创建对象这个工厂类包含一个方法根据输入的参数或条件来创建相应的对象实例。
举例
#include iostream
#include memory// 抽象产品类
class Product {
public:virtual void use() 0;virtual ~Product() {}
};// 具体产品类 A
class ConcreteProductA : public Product {
public:void use() override {std::cout Using ConcreteProductA\n;}
};// 具体产品类 B
class ConcreteProductB : public Product {
public:void use() override {std::cout Using ConcreteProductB\n;}
};// 简单工厂类
class SimpleFactory {
public:std::unique_ptrProduct createProduct(int type) {if (type 1) {return std::make_uniqueConcreteProductA();} else if (type 2) {return std::make_uniqueConcreteProductB();} else {return nullptr;}}
};int main() {SimpleFactory factory;std::unique_ptrProduct productA factory.createProduct(1);if (productA)productA-use();std::unique_ptrProduct productB factory.createProduct(2);if (productB)productB-use();return 0;
}工厂方法模式Factory Method Pattern
描述 工厂方法模式是一种创建型模式它定义了一个创建对象的接口但将实际创建工作推迟到子类中。每个子类都可以重写这个工厂方法以返回不同的对象实例。
举例
#include iostream
#include memory// 抽象产品类
class Product {
public:virtual void use() 0;virtual ~Product() {}
};// 具体产品类 A
class ConcreteProductA : public Product {
public:void use() override {std::cout Using ConcreteProductA\n;}
};// 具体产品类 B
class ConcreteProductB : public Product {
public:void use() override {std::cout Using ConcreteProductB\n;}
};// 抽象工厂类
class Factory {
public:virtual std::unique_ptrProduct createProduct() 0;virtual ~Factory() {}
};// 具体工厂类 A
class ConcreteFactoryA : public Factory {
public:std::unique_ptrProduct createProduct() override {return std::make_uniqueConcreteProductA();}
};// 具体工厂类 B
class ConcreteFactoryB : public Factory {
public:std::unique_ptrProduct createProduct() override {return std::make_uniqueConcreteProductB();}
};int main() {std::unique_ptrFactory factoryA std::make_uniqueConcreteFactoryA();std::unique_ptrProduct productA factoryA-createProduct();productA-use();std::unique_ptrFactory factoryB std::make_uniqueConcreteFactoryB();std::unique_ptrProduct productB factoryB-createProduct();productB-use();return 0;
}抽象工厂模式Abstract Factory Pattern
描述 抽象工厂模式提供一个接口来创建一系列相关或依赖对象的家族而不需要指定它们的具体类。它是工厂方法模式的扩展不仅仅是一个方法而是一个接口。
举例
#include iostream
#include memory// 抽象产品类 A
class AbstractProductA {
public:virtual void useA() 0;virtual ~AbstractProductA() {}
};// 具体产品类 A1
class ConcreteProductA1 : public AbstractProductA {
public:void useA() override {std::cout Using ConcreteProductA1\n;}
};// 具体产品类 A2
class ConcreteProductA2 : public AbstractProductA {
public:void useA() override {std::cout Using ConcreteProductA2\n;}
};// 抽象产品类 B
class AbstractProductB {
public:virtual void useB() 0;virtual ~AbstractProductB() {}
};// 具体产品类 B1
class ConcreteProductB1 : public AbstractProductB {
public:void useB() override {std::cout Using ConcreteProductB1\n;}
};// 具体产品类 B2
class ConcreteProductB2 : public AbstractProductB {
public:void useB() override {std::cout Using ConcreteProductB2\n;}
};// 抽象工厂类
class AbstractFactory {
public:virtual std::unique_ptrAbstractProductA createProductA() 0;virtual std::unique_ptrAbstractProductB createProductB() 0;virtual ~AbstractFactory() {}
};// 具体工厂类 1
class ConcreteFactory1 : public AbstractFactory {
public:std::unique_ptrAbstractProductA createProductA() override {return std::make_uniqueConcreteProductA1();}std::unique_ptrAbstractProductB createProductB() override {return std::make_uniqueConcreteProductB1();}
};// 具体工厂类 2
class ConcreteFactory2 : public AbstractFactory {
public:std::unique_ptrAbstractProductA createProductA() override {return std::make_uniqueConcreteProductA2();}std::unique_ptrAbstractProductB createProductB() override {return std::make_uniqueConcreteProductB2();}
};int main() {std::unique_ptrAbstractFactory factory1 std::make_uniqueConcreteFactory1();std::unique_ptrAbstractProductA productA1 factory1-createProductA();std::unique_ptrAbstractProductB productB1 factory1-createProductB();productA1-useA();productB1-useB();std::unique_ptrAbstractFactory factory2 std::make_uniqueConcreteFactory2();std::unique_ptrAbstractProductA productA2 factory2-createProductA();std::unique_ptrAbstractProductB productB2 factory2-createProductB();productA2-useA();productB2-useB();return 0;
}
