设计模式：简单工厂、工厂方法、抽象工厂的区别
简单工厂模式（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_ptr<Product> createProduct(int type) {
if (type == 1) {
return std::make_unique<ConcreteProductA>();
} else if (type == 2) {
return std::make_unique<ConcreteProductB>();
} else {
return nullptr;
}
}
};
int main() {
SimpleFactory factory;
std::unique_ptr<Product> productA = factory.createProduct(1);
if (productA)
productA->use();
std::unique_ptr<Product> 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_ptr<Product> createProduct() = 0;
virtual ~Factory() {
}
};
// 具体工厂类 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>();
std::unique_ptr<Product> productA = factoryA->createProduct();
productA->use();
std::unique_ptr<Factory> factoryB = std::make_unique<ConcreteFactoryB>();
std::unique_ptr<Product> 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_ptr<AbstractProductA> createProductA() = 0;
virtual std::unique_ptr<AbstractProductB> createProductB() = 0;
virtual ~AbstractFactory() {
}
};
// 具体工厂类 1
class ConcreteFactory1 : public AbstractFactory {
public:
std::unique_ptr<AbstractProductA> createProductA() override {
return std::make_unique<ConcreteProductA1>();
}
std::unique_ptr<AbstractProductB> createProductB() override {
return std::make_unique<ConcreteProductB1>();
}
};
// 具体工厂类 2
class ConcreteFactory2 : public AbstractFactory {
public:
std::unique_ptr<AbstractProductA> createProductA() override {
return std::make_unique<ConcreteProductA2>();
}
std::unique_ptr<AbstractProductB> createProductB() override {
return std::make_unique<ConcreteProductB2>();
}
};
int main() {
std::unique_ptr<AbstractFactory> factory1 = std::make_unique<ConcreteFactory1>();
std::unique_ptr<AbstractProductA> productA1 = factory1->createProductA();
std::unique_ptr<AbstractProductB> productB1 = factory1->createProductB();
productA1->useA();
productB1->useB();
std::unique_ptr<AbstractFactory> factory2 = std::make_unique<ConcreteFactory2>();
std::unique_ptr<AbstractProductA> productA2 = factory2->createProductA();
std::unique_ptr<AbstractProductB> productB2 = factory2->createProductB();
productA2->useA();
productB2->useB();
return 0;
}
