设计模式----抽象工厂模式【含实例】

今天学习抽象工厂模式。。。

--------------------------------------------------------------------------------------------

抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。

就是对一组具有相同主题的工厂进行封装。

例如：生产一台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

设计模式----抽象工厂模式 【含实例】

猜你喜欢

设计模式----抽象工厂模式【含实例】