借鉴:(29条消息) C++设计模式 - 简单工厂,工厂方法和抽象工厂_大秦坑王的博客-CSDN博客https://blog.csdn.net/QIANGWEIYUAN/article/details/88792594
简单工厂 simple factory :
所有对象的创建不再通过new类名称的方式进行了,而是把对象的创建都封装在了SimpleFactory类的create方法中,事先传入一个设计好的枚举类型,然后返回一个对应的对象。
把对象的创建封装在一个接口函数中,通过传入不同的标识,返回创建的对象,客户不用自己负责new对象,不用了解对象创建的详细过程。
#include<iostream>
#include<string>
#include<memory>
using namespace std;
class Car
{
public:
Car(string name) : _name(name){}
virtual void show() = 0;
protected:
string _name;
};
class Bmw : public Car
{
public:
Bmw(string name) : Car(name) {}
void show()
{
cout << "获取了一辆宝马汽车: " << _name << endl;
}
};
class Audi : public Car
{
public:
Audi(string name) : Car(name) {}
void show()
{
cout << "获取了一辆奥迪汽车: " << _name << endl;
}
};
enum CarType
{
BMW, AUDI
};
class SimpleFactory
{
public:
Car* createCar(CarType ct)
{
switch (ct)
{
case BMW:
return new Bmw("X1");
case AUDI:
return new Audi("A6");
default:
cerr << "传入工厂的参数不正确:" << ct << endl;
break;
}
return nullptr;
}
};
int main()
{
unique_ptr<SimpleFactory> factory (new SimpleFactory());
unique_ptr<Car> p1 (factory->createCar(BMW));
unique_ptr<Car> p2 (factory->createCar(AUDI));
p1->show();
p2->show();
return 0;
}
提供创建对象实例的接口函数不闭合,不能对修改关闭。
工厂方法 factory method:
factory基类,提供了一个纯虚函数(创建产品),定义派生类(具体产品的工厂)负责创建对应的产品,可以做到不同产品在不同工厂里面创建,能够对现有工厂以及产品的修改关闭。
#include<iostream>
#include<string>
#include<memory>
using namespace std;
class Car
{
public:
Car(string name) : _name(name){}
virtual void show() = 0;
protected:
string _name;
};
class Bmw : public Car
{
public:
Bmw(string name) : Car(name) {}
void show()
{
cout << "获取了一辆宝马汽车: " << _name << endl;
}
};
class Audi : public Car
{
public:
Audi(string name) : Car(name) {}
void show()
{
cout << "获取了一辆奥迪汽车: " << _name << endl;
}
};
//工厂方法
class Factory
{
public:
virtual Car* createCar(string name) = 0; //工厂方法
};
//宝马工厂
class BMWFactory : public Factory
{
public:
Car* createCar(string name)
{
return new Bmw(name);
}
};
//奥迪工厂
class AUDIFactory : public Factory
{
public:
Car* createCar(string name)
{
return new Audi(name);
}
};
int main()
{
unique_ptr<Factory> bmwfty(new BMWFactory());
unique_ptr<Factory> audifty(new AUDIFactory());
unique_ptr<Car> p1(bmwfty->createCar("X6"));
unique_ptr<Car> p2(audifty->createCar("A8"));
p1->show();
p2->show();
}
实际上,很多产品是有关联关系的,属于一个产品簇,不应该放在不同的工厂里面去创建,这样一是不符合实际的产品对象创建逻辑,二是工厂类太多! 不好维护
抽象工厂 abstract factory:
把有关联关系的,属于一个产品簇的所有产品创建的接口函数,放在一个抽象工厂里面,派生类(具体产品工厂)负责生产整个产品簇里面所有的产品。
#include<iostream>
#include<string>
#include<memory>
using namespace std;
//系列产品1
class Car
{
public:
Car(string name) : _name(name){}
virtual void show() = 0;
protected:
string _name;
};
class Bmw : public Car
{
public:
Bmw(string name) : Car(name) {}
void show()
{
cout << "获取了一辆宝马汽车: " << _name << endl;
}
};
class Audi : public Car
{
public:
Audi(string name) : Car(name) {}
void show()
{
cout << "获取了一辆奥迪汽车: " << _name << endl;
}
};
//系列产品2
class Light
{
public:
virtual void show() = 0;
};
class BmwLight : public Light
{
public:
void show() { cout << "BMW light!" << endl; }
};
class AudiLight : public Light
{
public:
void show() { cout << "Audi light!" << endl; }
};
//抽象工厂
class AbstractFactory
{
public:
virtual Car* createCar(string name) = 0; //工厂方法 创建汽车
virtual Light* createCarLight() = 0; //工厂方法 创建汽车关联的产品 车灯
};
//宝马工厂
class BMWFactory : public AbstractFactory
{
public:
Car* createCar(string name)
{
return new Bmw(name);
}
Light* createCarLight() {
return new BmwLight();
}
};
//奥迪工厂
class AUDIFactory : public AbstractFactory
{
public:
Car* createCar(string name)
{
return new Audi(name);
}
Light* createCarLight() {
return new AudiLight();
}
};
int main()
{
unique_ptr<AbstractFactory> bmwfty(new BMWFactory());
unique_ptr<AbstractFactory> audifty(new AUDIFactory());
unique_ptr<Car> p1(bmwfty->createCar("X6"));
unique_ptr<Car> p2(audifty->createCar("A8"));
unique_ptr<Light> l1(bmwfty->createCarLight());
unique_ptr<Light> l2(audifty->createCarLight());
p1->show();
l1->show();
p2->show();
l2->show();
}
总的来说:
简单工厂模式:所有对象的创建封装在一个工厂类中,通过事先定义好的类型枚举,使用时只需要提供类请求对象即可;
工厂方法模式:对象的创建交给具体的子类工厂来实现,工厂类提供一个纯虚函数;
抽象工厂模式:相关的对象封装在一个工厂中。