工厂模式是一种创建型的设计模式，他提供了一种创建对象的最佳方式，而无需指定将要创建对象的具体类。

包括：简单工厂模式、工厂方法模式、抽象工厂模式。

简单工厂模式

组成成员：抽象产品类、具体产品类 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;
}

优点：功能更加丰富，一种工厂可以生产不同产品的不同部件。

共同的优点