工厂模式介绍

文章介绍了C++中的三种设计模式:简单工厂模式用于集中创建对象,通过枚举类型指定返回对象类型;工厂方法模式将对象创建职责交给子类工厂,实现了开闭原则;抽象工厂模式则用于创建相关产品簇,确保相关对象一起被正确创建。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

借鉴:(29条消息) C++设计模式 - 简单工厂,工厂方法和抽象工厂_大秦坑王的博客-优快云博客icon-default.png?t=N5F7https://blog.youkuaiyun.com/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();

}

总的来说:

        简单工厂模式:所有对象的创建封装在一个工厂类中,通过事先定义好的类型枚举,使用时只需要提供类请求对象即可;

        工厂方法模式:对象的创建交给具体的子类工厂来实现,工厂类提供一个纯虚函数;

        抽象工厂模式:相关的对象封装在一个工厂中。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值