工廠模式是一種創建型的設計模式，他提供了一種創建對象的最佳方式，而無需指定將要創建對象的具體類。
包括：簡單工廠模式、工廠方法模式、抽象工廠模式。
簡單工廠模式
組成成員：抽象產品類、具體產品類 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;
}
優點：功能更加豐富，一種工廠可以生產不同產品的不同部件。
共同的優點
工廠模式的優點
松耦合：將對象的創建與使用分離
可擴展性：添加新產品時只需添加新的工廠類
單一職責原則：將創建邏輯集中在一個地方
開閉原則：無需修改現有代碼即可引入新產品
使用場景
當一個類不知道它需要創建哪個類的對象時，簡單工廠模式
當一個類希望由其子類來指定它所創建的對象時，工廠方法模式
當需要提供一組相關對象時（抽象工廠模式，抽象工廠模式
)
