工厂方法模式与抽象工厂模式

首先是一个工厂方法模式：

#include <iostream>
#include <string>
using namespace std;

// 抽象产品类
class Car {
public:
    virtual void Run() = 0; // 纯虚函数，定义产品接口
    virtual ~Car() {} // 虚析构函数，保证多态删除
};

// 具体产品类：宝马
class BMWCar : public Car {
public:
    void Run() override {
        cout << "I am BMW" << endl;
    }
};

// 具体产品类：奥迪
class AoDiCar : public Car {
public:
    void Run() override {
        cout << "I am Audi" << endl;
    }
};

// 抽象工厂类
class CarFactory {
public:
    virtual Car* CreateCar() = 0; // 纯虚函数，定义工厂接口
};

// 具体工厂类：生产宝马的工厂
class BMWFactory : public CarFactory {
public:
    Car* CreateCar() override {
        return new BMWCar();
    }
};

// 具体工厂类：生产奥迪的工厂
class AoDiFactory : public CarFactory {
public:
    Car* CreateCar() override {
        return new AoDiCar();
    }
};

int main() {
    // 客户端代码
    CarFactory* carFactory1 = new BMWFactory(); // 创建一个宝马工厂
    Car* car1 = carFactory1->CreateCar(); // 通过工厂创建宝马汽车
    car1->Run(); // 运行宝马汽车

    CarFactory* carFactory2 = new AoDiFactory(); // 创建一个奥迪工厂
    Car* car2 = carFactory2->CreateCar(); // 通过工厂创建奥迪汽车
    car2->Run(); // 运行奥迪汽车

    // 释放内存
    delete car1;
    delete carFactory1;
    delete car2;
    delete carFactory2;

    return 0;
}

以下是抽象工厂模式：
要将上述代码从工厂方法模式改为抽象工厂模式，我们需要引入一个额外的抽象层，以便能够创建不同类型的汽车部件（而不仅仅是汽车本身）。在抽象工厂模式中，一个工厂类负责创建一系列相关或相互依赖的对象，而无需明确指定它们的具体类。

以下是一个简化的抽象工厂模式示例，其中我们假设汽车有两个部件：发动机（Engine）和轮胎（Tire）。我们将创建这些部件的抽象类，并为宝马和奥迪分别提供具体的实现。然后，我们将创建一个抽象工厂来定义创建这些部件的方法，并为宝马和奥迪提供具体的工厂实现。

首先，我们定义抽象产品类：

cpp
#include
#include
using namespace std;

// 抽象产品类：发动机
class Engine {
public:
virtual void Start() = 0; // 纯虚函数，定义产品接口
virtual ~Engine() {} // 虚析构函数，保证多态删除
};

// 抽象产品类：轮胎
class Tire {
public:
virtual void Rotate() = 0; // 纯虚函数，定义产品接口
virtual ~Tire() {} // 虚析构函数，保证多态删除
};

// 具体产品类：宝马发动机
class BMWEngine : public Engine {
public:
void Start() override {
cout << “BMW Engine Starts” << endl;
}
};

// 具体产品类：宝马轮胎
class BMWTire : public Tire {
public:
void Rotate() override {
cout << “BMW Tires Rotate” << endl;
}
};

// 具体产品类：奥迪发动机
class AudiEngine : public Engine {
public:
void Start() override {
cout << “Audi Engine Starts” << endl;
}
};

// 具体产品类：奥迪轮胎
class AudiTire : public Tire {
public:
void Rotate() override {
cout << “Audi Tires Rotate” << endl;
}
};
接下来，我们定义抽象工厂类：

cpp
// 抽象工厂类
class CarFactory {
public:
virtual Engine* CreateEngine() = 0; // 纯虚函数，定义工厂接口
virtual Tire* CreateTire() = 0; // 纯虚函数，定义工厂接口
};
然后，我们为宝马和奥迪提供具体的工厂实现：

cpp
// 具体工厂类：宝马工厂
class BMWFactory : public CarFactory {
public:
Engine* CreateEngine() override {
return new BMWEngine();
}

Tire* CreateTire() override {
    return new BMWTire();
}

};

// 具体工厂类：奥迪工厂
class AudiFactory : public CarFactory {
public:
Engine* CreateEngine() override {
return new AudiEngine();
}

Tire* CreateTire() override {
    return new AudiTire();
}

};
最后，在客户端代码中，我们使用工厂来创建汽车部件：

cpp
int main() {
// 客户端代码
CarFactory* bmwFactory = new BMWFactory(); // 创建一个宝马工厂
Engine* bmwEngine = bmwFactory->CreateEngine(); // 通过工厂创建宝马发动机
Tire* bmwTire = bmwFactory->CreateTire(); // 通过工厂创建宝马轮胎

bmwEngine->Start(); // 启动宝马发动机
bmwTire->Rotate();  // 让宝马轮胎旋转

CarFactory* audiFactory = new AudiFactory(); // 创建一个奥迪工厂
Engine* audiEngine = audiFactory->CreateEngine(); // 通过工厂创建奥迪发动机
Tire* audiTire = audiFactory->CreateTire();       // 通过工厂创建奥迪轮胎

audiEngine->Start(); // 启动奥迪发动机
audiTire->Rotate();  // 让奥迪轮胎旋转

// 释放内存（注意：在实际应用中，更推荐使用智能指针来管理内存）
delete bmwEngine;
delete bmwTire;
delete bmwFactory;
delete audiEngine;
delete audiTire;
delete audiFactory;

return 0;

}
请注意，在这个示例中，我们没有直接创建一个“汽车”类，而是创建了汽车的部件（发动机和轮胎）。这是因为抽象工厂模式通常用于创建一系列相关的对象，而不是单个对象。在实际应用中，你可能会有一个“汽车”类，它接受发动机和轮胎作为参数，并在其内部使用它们。此外，为了简化示例，我使用了原始指针和手动内存管理。在实际项目中，更推荐使用智能指针（如 std::unique_ptr 或 std::shared_ptr）来自动管理内存。

工厂方法模式与抽象工厂模式

悦读