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

发布于:2024-11-29 ⋅ 阅读:(32) ⋅ 点赞:(0)

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

#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)来自动管理内存。