工厂模式是一种创建型的设计模式，他提供了一种创建对象的最佳方式，而无需指定将要创建对象的具体类。
包括：简单工厂模式、工厂方法模式、抽象工厂模式。
简单工厂模式
组成成员：抽象产品类、具体产品类 A、B、C等、工厂类
工作原理：具体产品类A、B、C等抽象出相同的输入参数，然后通过继承抽象产品类。工厂类具体就是具体实例化相应的产品。
#include <iostream>
#include <memory>
// 产品接口
class Product {
public:
virtual void operation() = 0;
virtual ~Product() = default;
};
// 具体产品A
class ConcreteProductA : public Product {
public:
void operation() override {
std::cout << "ConcreteProductA operation" << std::endl;
}
};
// 具体产品B
class ConcreteProductB : public Product {
public:
void operation() override {
std::cout << "ConcreteProductB operation" << std::endl;
}
};
// 简单工厂
class SimpleFactory {
public:
enum ProductType { A, B };
std::unique_ptr<Product> createProduct(ProductType type) {
switch (type) {
case A: return std::make_unique<ConcreteProductA>();
case B: return std::make_unique<ConcreteProductB>();
default: return nullptr;
}
}
};
int main() {
SimpleFactory factory;
auto productA = factory.createProduct(SimpleFactory::A);
productA->operation(); // 输出: ConcreteProductA operation
auto productB = factory.createProduct(SimpleFactory::B);
productB->operation(); // 输出: ConcreteProductB operation
return 0;
}
优点：
1.符合类的单一职责原则。
2.隐藏了具体产品类的实现细节。
工厂方法模式
组成成员：抽象产品类、具体产品类 A、B、C等、抽象工厂类A、B、C
工作原理：具体产品类A、B、C等抽象出相同的输入参数，然后通过继承抽象产品类。工厂A、B、C继承自一个抽象工厂。产品A、B、C 分别由A、B、C工厂生产。
#include <iostream>
#include <memory>
// 产品接口
class Product {
public:
virtual void operation() = 0;
virtual ~Product() = default;
};
// 具体产品A
class ConcreteProductA : public Product {
public:
void operation() override {
std::cout << "ConcreteProductA operation" << std::endl;
}
};
// 具体产品B
class ConcreteProductB : public Product {
public:
void operation() override {
std::cout << "ConcreteProductB operation" << std::endl;
}
};
// 工厂接口
class Factory {
public:
virtual std::unique_ptr<Product> createProduct() = 0;
virtual ~Factory() = default;
};
// 具体工厂A
class ConcreteFactoryA : public Factory {
public:
std::unique_ptr<Product> createProduct() override {
return std::make_unique<ConcreteProductA>();
}
};
// 具体工厂B
class ConcreteFactoryB : public Factory {
public:
std::unique_ptr<Product> createProduct() override {
return std::make_unique<ConcreteProductB>();
}
};
int main() {
std::unique_ptr<Factory> factoryA = std::make_unique<ConcreteFactoryA>();
auto productA = factoryA->createProduct();
productA->operation(); // 输出: ConcreteProductA operation
std::unique_ptr<Factory> factoryB = std::make_unique<ConcreteFactoryB>();
auto productB = factoryB->createProduct();
productB->operation(); // 输出: ConcreteProductB operation
return 0;
}
优点：
1.细化了工厂的实现功能。
抽象工厂模式
组成成员：抽象产品 A，具体产品A1,具体产品A2。抽象产品B，具体产品B1,具体产品B。
抽象工厂、具体工厂A、B
工作原理：具体产品A1和A2继承产品A。具体产品B1和B2继承产品B。工厂A负责生产A1和A2两种产品。工厂B负责生产B1和B2两种产品。
#include <iostream>
#include <memory>
// 抽象产品A
class AbstractProductA {
public:
virtual void operationA() = 0;
virtual ~AbstractProductA() = default;
};
// 具体产品A1
class ProductA1 : public AbstractProductA {
public:
void operationA() override {
std::cout << "ProductA1 operation" << std::endl;
}
};
// 具体产品A2
class ProductA2 : public AbstractProductA {
public:
void operationA() override {
std::cout << "ProductA2 operation" << std::endl;
}
};
// 抽象产品B
class AbstractProductB {
public:
virtual void operationB() = 0;
virtual ~AbstractProductB() = default;
};
// 具体产品B1
class ProductB1 : public AbstractProductB {
public:
void operationB() override {
std::cout << "ProductB1 operation" << std::endl;
}
};
// 具体产品B2
class ProductB2 : public AbstractProductB {
public:
void operationB() override {
std::cout << "ProductB2 operation" << std::endl;
}
};
// 抽象工厂
class AbstractFactory {
public:
virtual std::unique_ptr<AbstractProductA> createProductA() = 0;
virtual std::unique_ptr<AbstractProductB> createProductB() = 0;
virtual ~AbstractFactory() = default;
};
// 具体工厂1
class ConcreteFactory1 : public AbstractFactory {
public:
std::unique_ptr<AbstractProductA> createProductA() override {
return std::make_unique<ProductA1>();
}
std::unique_ptr<AbstractProductB> createProductB() override {
return std::make_unique<ProductB1>();
}
};
// 具体工厂2
class ConcreteFactory2 : public AbstractFactory {
public:
std::unique_ptr<AbstractProductA> createProductA() override {
return std::make_unique<ProductA2>();
}
std::unique_ptr<AbstractProductB> createProductB() override {
return std::make_unique<ProductB2>();
}
};
int main() {
std::unique_ptr<AbstractFactory> factory1 = std::make_unique<ConcreteFactory1>();
auto productA1 = factory1->createProductA();
auto productB1 = factory1->createProductB();
productA1->operationA(); // 输出: ProductA1 operation
productB1->operationB(); // 输出: ProductB1 operation
std::unique_ptr<AbstractFactory> factory2 = std::make_unique<ConcreteFactory2>();
auto productA2 = factory2->createProductA();
auto productB2 = factory2->createProductB();
productA2->operationA(); // 输出: ProductA2 operation
productB2->operationB(); // 输出: ProductB2 operation
return 0;
}
优点：功能更加丰富，一种工厂可以生产不同产品的不同部件。
共同的优点
工厂模式的优点
-
松耦合：将对象的创建与使用分离
-
可扩展性：添加新产品时只需添加新的工厂类
-
单一职责原则：将创建逻辑集中在一个地方
-
开闭原则：无需修改现有代码即可引入新产品
使用场景
-
当一个类不知道它需要创建哪个类的对象时，简单工厂模式
-
当一个类希望由其子类来指定它所创建的对象时，工厂方法模式
-
当需要提供一组相关对象时（抽象工厂模式，抽象工厂模式