C++工厂模式全解析：从简单工厂到抽象工厂的进阶之路
在软件设计中，工厂模式（Factory Pattern）是一类创建型设计模式，用于将对象的创建过程和使用过程解耦。这种设计模式在面向对象编程中非常常见，特别是在构建复杂系统时，工厂模式可以使代码更加灵活、模块化、易于扩展。
工厂模式的主要类型包括：
- 简单工厂模式（Simple Factory）
- 工厂方法模式（Factory Method）
- 抽象工厂模式（Abstract Factory）
以下，我们会详细介绍每种模式的概念、适用场景以及 C++ 实现方式。
1. 简单工厂模式
概念
简单工厂模式（Simple Factory）提供了一个创建对象的接口，根据不同的条件创建不同的对象。简单工厂模式通常使用一个独立的工厂类，通过传入参数来决定实例化哪个具体的类对象。
适用场景
当系统需要创建的对象较少，且没有复杂的继承结构时，简单工厂模式是一种快速实现的方案。但当类的种类增多时，简单工厂会变得臃肿。
C++ 实现
假设我们需要一个工厂来创建不同类型的“汽车”对象，包括CarA和CarB。
#include <iostream>
#include <memory>
using namespace std;
// 抽象产品类
class Car {
public:
virtual void show() = 0; // 纯虚函数
};
// 具体产品类 A
class CarA : public Car {
public:
void show() override {
cout << "This is Car A." << endl;
}
};
// 具体产品类 B
class CarB : public Car {
public:
void show() override {
cout << "This is Car B." << endl;
}
};
// 简单工厂类
class SimpleCarFactory {
public:
static unique_ptr<Car> createCar(const string& type) {
if (type == "A") {
return make_unique<CarA>();
} else if (type == "B") {
return make_unique<CarB>();
} else {
return nullptr;
}
}
};
// 测试代码
int main() {
auto carA = SimpleCarFactory::createCar("A");
auto carB = SimpleCarFactory::createCar("B");
if (carA) carA->show();
if (carB) carB->show();
return 0;
}
说明
SimpleCarFactory类中使用静态方法createCar创建不同的汽车实例。createCar方法接收一个string类型的参数type，通过判断type的值来返回不同的Car子类对象。- 客户端无需关心具体的类，只需调用工厂类来创建对象。
优缺点
- 优点：客户端与具体类解耦，易于使用。
- 缺点：增加新的产品类型需要修改工厂类，违反了开闭原则。
2. 工厂方法模式
概念
工厂方法模式（Factory Method Pattern）通过定义一个创建对象的接口，让子类决定实例化哪个类。工厂方法模式将对象的实例化推迟到子类完成，属于典型的面向对象设计。
适用场景
当系统中存在复杂的对象层次结构，需要通过子类来实现实例化的细节时，可以使用工厂方法模式。
C++ 实现
假设我们有多种类型的汽车，每种汽车都有自己的工厂。
#include <iostream>
#include <memory>
using namespace std;
// 抽象产品类
class Car {
public:
virtual void show() = 0;
};
// 具体产品类 A
class CarA : public Car {
public:
void show() override {
cout << "This is Car A." << endl;
}
};
// 具体产品类 B
class CarB : public Car {
public:
void show() override {
cout << "This is Car B." << endl;
}
};
// 抽象工厂类
class CarFactory {
public:
virtual unique_ptr<Car> createCar() = 0; // 纯虚函数
};
// 具体工厂类 A
class CarAFactory : public CarFactory {
public:
unique_ptr<Car> createCar() override {
return make_unique<CarA>();
}
};
// 具体工厂类 B
class CarBFactory : public CarFactory {
public:
unique_ptr<Car> createCar() override {
return make_unique<CarB>();
}
};
// 测试代码
int main() {
unique_ptr<CarFactory> factoryA = make_unique<CarAFactory>();
unique_ptr<CarFactory> factoryB = make_unique<CarBFactory>();
auto carA = factoryA->createCar();
auto carB = factoryB->createCar();
carA->show();
carB->show();
return 0;
}
说明
CarFactory是抽象工厂类，定义了创建Car的接口。CarAFactory和CarBFactory是具体工厂类，实现了createCar方法，分别返回CarA和CarB实例。- 客户端只需使用工厂类生成产品对象，不必了解具体的实现细节。
优缺点
- 优点：符合开闭原则，增加新产品时无需修改已有代码。
- 缺点：每新增一种产品，需要创建对应的工厂类，增加了系统复杂性。
3. 抽象工厂模式
概念
抽象工厂模式（Abstract Factory Pattern）是工厂模式的扩展，提供一个接口，用于创建一组相关或相互依赖的对象。抽象工厂模式适合需要创建多种产品类型的系统。
适用场景
当系统中存在多个产品族，并且客户端需要使用其中某一产品族的所有产品时，可以使用抽象工厂模式。
C++ 实现
假设我们有不同系列的汽车和轮胎，每个系列的汽车使用特定的轮胎。
#include <iostream>
#include <memory>
using namespace std;
// 抽象产品类：Car
class Car {
public:
virtual void show() = 0;
};
// 具体产品类：CarA
class CarA : public Car {
public:
void show() override {
cout << "This is Car A." << endl;
}
};
// 具体产品类：CarB
class CarB : public Car {
public:
void show() override {
cout << "This is Car B." << endl;
}
};
// 抽象产品类：Tire
class Tire {
public:
virtual void type() = 0;
};
// 具体产品类：TireA
class TireA : public Tire {
public:
void type() override {
cout << "This is Tire A for Car A." << endl;
}
};
// 具体产品类：TireB
class TireB : public Tire {
public:
void type() override {
cout << "This is Tire B for Car B." << endl;
}
};
// 抽象工厂类
class AbstractCarFactory {
public:
virtual unique_ptr<Car> createCar() = 0;
virtual unique_ptr<Tire> createTire() = 0;
};
// 具体工厂类 A
class CarAFactory : public AbstractCarFactory {
public:
unique_ptr<Car> createCar() override {
return make_unique<CarA>();
}
unique_ptr<Tire> createTire() override {
return make_unique<TireA>();
}
};
// 具体工厂类 B
class CarBFactory : public AbstractCarFactory {
public:
unique_ptr<Car> createCar() override {
return make_unique<CarB>();
}
unique_ptr<Tire> createTire() override {
return make_unique<TireB>();
}
};
// 测试代码
int main() {
unique_ptr<AbstractCarFactory> factoryA = make_unique<CarAFactory>();
unique_ptr<AbstractCarFactory> factoryB = make_unique<CarBFactory>();
auto carA = factoryA->createCar();
auto tireA = factoryA->createTire();
carA->show();
tireA->type();
auto carB = factoryB->createCar();
auto tireB = factoryB->createTire();
carB->show();
tireB->type();
return 0;
}
说明
AbstractCarFactory是抽象工厂类，定义了创建Car和Tire的接口。CarAFactory和CarBFactory是具体工厂类，实现了createCar和createTire方法，分别返回与其产品族相关的产品。- 客户端只需使用特定工厂类生成产品族中的对象，无需了解具体的实现。
优缺点
- 优点：支持创建一系列