今天学习抽象工厂模式。。。
--------------------------------------------------------------------------------------------
抽象工厂模式是指当有多个抽象角色时,使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口,使客户端在不必指定产品的具体的情况下,创建多个产品族中的产品对象。
就是对一组具有相同主题的工厂进行封装。
例如:生产一台PC机,使用工厂方法模式的话,一般会有cpu工厂,内存工厂,显卡工厂...但是使用抽象工厂模式的话,只有一个工厂就是PC工厂,但是一个PC工厂涵盖了cpu工厂,内存工厂,显卡工厂等要做的所有事。
注意:这里的“相同主题”的概念,表示的是同一个产品族,不能将cpu工厂,面粉工厂封装成一个工厂,因为他们不属于同一个产品族。
实现
1.各个产品抽象类,CUP产品类,Memory产品类,VideoCard产品类。
2.一个工厂抽象类,PC工厂,包含建造所有产品的能力,可以提供一个创建工厂的接口。
3.具体产品类继承自产品抽象类,如惠普CPU类继承CPU产品类,联想显卡继承VideoCard类。
4.具体工厂类继承工厂抽象类,如惠普工厂,联想工厂,继承PC工厂类。
代码
//main.h
#ifndef MAIN_H
#define MAIN_H
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
/产品抽象类/
class CPU
{
public:
virtual ~CPU(){}
virtual void printProductInfo() = 0;
};
class VideoCard
{
public:
virtual ~VideoCard(){}
virtual void printProductInfo() = 0;
};
class Memory
{
public:
virtual ~Memory(){}
Memory(int size){m_memeorySize = size;}
virtual void printProductInfo() = 0;
int m_memeorySize;
};
///PC工厂抽象类
class IFactory{
public:
virtual ~IFactory(){std::cout<<"~IFactory()"<<std::endl;}
enum FACTORYTYPE{
TYPE_HP,
TYPE_LENOVO
};
//创造产品的接口,子类可根据需求去创造不同的产品
virtual CPU* createCPU() = 0;
virtual VideoCard* createVideoCard() = 0;
virtual Memory* createMemory() = 0;
//创建工厂的接口
static IFactory* createFactory(FACTORYTYPE type);
};
具体工厂类/
class HPFactory : public IFactory
{
public:
~HPFactory(){std::cout<<"~HPFactory()"<<std::endl;}
//创造惠普的CPU
virtual CPU* createCPU();
//创造惠普的显卡
virtual VideoCard* createVideoCard();
//创造惠普的内存
virtual Memory* createMemory();
private:
};
class LENOVOFactory : public IFactory
{
public:
virtual ~LENOVOFactory(){}
virtual CPU* createCPU();
virtual VideoCard* createVideoCard();
virtual Memory* createMemory();
private:
};
具体产品类/
class HP_CPU:public CPU
{
public:
virtual ~HP_CPU(){}
virtual void printProductInfo()
{
std::cout<<"[HP CPU INFO]"<<std::endl;
}
};
class LENOVO_CPU:public CPU
{
public:
virtual ~LENOVO_CPU(){}
virtual void printProductInfo()
{
std::cout<<"[LENOVO CPU INFO]"<<std::endl;
}
};
class HP_VC:public VideoCard
{
public:
virtual ~HP_VC(){}
virtual void printProductInfo()
{
std::cout<<"[HP VideoCard Info]"<<std::endl;
}
};
class LENOVO_VC:public VideoCard
{
public:
virtual ~LENOVO_VC(){}
virtual void printProductInfo()
{
std::cout<<"[LENOVO VideoCard Info]"<<std::endl;
}
};
class HP_MEM:public Memory
{
public:
virtual ~HP_MEM(){}
HP_MEM(int size):Memory(size){}
virtual void printProductInfo()
{
std::cout<<"[HP MEM]memeorySize:"<<m_memeorySize<<std::endl;
}
};
class LENOVO_MEM:public Memory
{
public:
virtual ~LENOVO_MEM(){}
LENOVO_MEM(int size):Memory(size){}
virtual void printProductInfo()
{
std::cout<<"[LENOVO MEM]memeorySize:"<<m_memeorySize<<std::endl;
}
};
#endif // MAIN_H
//main.cpp
#include "main.h"
#include "unistd.h"
#define RELEASE(p) {if(p) {delete p; p = NULL;}}
IFactory* IFactory::createFactory(FACTORYTYPE type)
{
if(type == TYPE_HP)
{
std::cout<<"create HP Factory!"<<std::endl;
IFactory* pHpFactory = new HPFactory();
return pHpFactory;
}else{
std::cout<<"create LENOVO Factory!"<<std::endl;
IFactory* pLenovoFactory = new LENOVOFactory();
return pLenovoFactory;
}
}
CPU* HPFactory::createCPU()
{
std::cout<<"create HP CPU!"<<std::endl;
HP_CPU* pCpu = new HP_CPU();
return pCpu;
}
VideoCard* HPFactory::createVideoCard()
{
std::cout<<"create HP VideoCard!"<<std::endl;
return new HP_VC();
}
Memory* HPFactory::createMemory()
{
std::cout<<"create HP Memory!"<<std::endl;
return new HP_MEM(16);
}
CPU* LENOVOFactory::createCPU()
{
std::cout<<"create LENOVO CPU!"<<std::endl;
LENOVO_CPU* pCpu = new LENOVO_CPU();
return pCpu;
}
VideoCard* LENOVOFactory::createVideoCard()
{
std::cout<<"create LENOVO VideoCard!"<<std::endl;
return new LENOVO_VC();
}
Memory* LENOVOFactory::createMemory()
{
std::cout<<"create LENOVO Memory!"<<std::endl;
return new LENOVO_MEM(64);
}
int main(int argc, char *argv[])
{
printf("========hello======\n");
IFactory* factory_1 = IFactory::createFactory(IFactory::TYPE_HP);
CPU* cpu_1 = factory_1->createCPU();
VideoCard* vc_1 = factory_1->createVideoCard();
cpu_1->printProductInfo();
vc_1->printProductInfo();
IFactory* factory_2 = IFactory::createFactory(IFactory::TYPE_LENOVO);
CPU* cpu_2 = factory_2->createCPU();
Memory* mem_1 = factory_2->createMemory();
cpu_2->printProductInfo();
mem_1->printProductInfo();
printf("-------exit--------\n");
RELEASE(factory_1);
RELEASE(cpu_1);
RELEASE(vc_1);
RELEASE(factory_2);
RELEASE(cpu_2);
RELEASE(mem_1);
return 0;
}
输出
Starting /home/user/build-TestList-Desktop_Qt_5_9_5_GCC_64bit-Debug/TestList...
========hello======
create HP Factory!
create HP CPU!
create HP VideoCard!
[HP CPU INFO]
[HP VideoCard Info]
create LENOVO Factory!
create LENOVO CPU!
create LENOVO Memory!
[LENOVO CPU INFO]
[LENOVO MEM]memeorySize:64
-------exit--------
~HPFactory()
~IFactory()
~IFactory()
/home/user/build-TestList-Desktop_Qt_5_9_5_GCC_64bit-Debug/TestList exited with code 0
总结
这种写法真的代码太多了.....
继续添加产品,就需要添加相应生产方法。
使用时比较简单,只要知道工厂类型就可以了,封装了产品的创造 。
给自己的注意:
资源释放,基类析构声明为虚析构函数,才能调用到子类的析构函数。
---------------------------------------------------------------------------------------------------------
有问题欢迎指出~
参考资料
https://www.cnblogs.com/chenpi/p/5156801.html
https://blog.csdn.net/liang19890820/article/details/70653800