学习笔记——抽象工厂模式Abstract Factory

在工厂模式的基础上，通过为工厂类增加接口，实现其他产品的生产，而不用一类产品就增加一个工厂。

依然以《真菌世界》游戏故事类比，树作为工厂，如果现在有两类树，一类生产快速弄真菌飞机和20毫米炮，一类生产慢速弄真菌飞机和10毫米炮。

产品类：

真菌飞机接口

IFungus.h

#pragma once
class IFungus
{
public:
    IFungus(void);
    virtual ~IFungus(void);
public:
    virtual void Fight()=0;
};

IFungus.cpp

#include "IFungus.h"


IFungus::IFungus(void)
{
}


IFungus::~IFungus(void)
{
}

真菌飞机A

FungusA.h

#pragma once
#include "ifungus.h"
class CFungusA :
    public IFungus
{
public:
    CFungusA(void);
    ~CFungusA(void);
public:
    void Fight();
};

FungusA.cpp

#include "FungusA.h"
#include <iostream>

CFungusA::CFungusA(void)
{
}


CFungusA::~CFungusA(void)
{
}

void CFungusA::Fight()
{
    std::cout<<"快速攻击型"<<std::endl;
}

真菌飞机B

FungusB.h

#pragma once
#include "ifungus.h"
class CFungusB :
    public IFungus
{
public:
    CFungusB(void);
    ~CFungusB(void);
public:
    void Fight();
};

FungusB.cpp

#include "FungusB.h"
#include <iostream>

CFungusB::CFungusB(void)
{
}


CFungusB::~CFungusB(void)
{
}

void CFungusB::Fight()
{
    std::cout<<"慢慢攻击型"<<std::endl;
}

炮接口

ICannon.h

#pragma once
class ICannon
{
public:
    ICannon(void);
    virtual ~ICannon(void);
public:
    virtual void Fire() = 0;
};

ICannon.cpp

#include "ICannon.h"


ICannon::ICannon(void)
{
}


ICannon::~ICannon(void)
{
}

炮A

CannonA.h

#pragma once
#include "icannon.h"
class CCannonA :
    public ICannon
{
public:
    CCannonA(void);
    ~CCannonA(void);
public:
    void Fire();
};

CannonA.cpp

#include "CannonA.h"
#include <iostream>

CCannonA::CCannonA(void)
{
}


CCannonA::~CCannonA(void)
{
}

void CCannonA::Fire()
{
    std::cout<<"使用10毫米弹"<<std::endl;
}

炮B

CannonB.h

#pragma once
#include "icannon.h"
class CCannonB :
    public ICannon
{
public:
    CCannonB(void);
    ~CCannonB(void);
public:
    void Fire();
};

CannonB.cpp

#include "CannonB.h"
#include <iostream>

CCannonB::CCannonB(void)
{
}


CCannonB::~CCannonB(void)
{
}

void CCannonB::Fire()
{
    std::cout<<"使用20毫米弹"<<std::endl;
}

工厂类：

树接口

ITree.h

#pragma once
#include "IFungus.h"
#include "ICannon.h"

class ITree
{
public:
    ITree(void);
    virtual ~ITree(void);
public:
    virtual IFungus* GetFungus() = 0;
    virtual ICannon* GetCannon() = 0;
};

ITree.cpp

#include "ITree.h"


ITree::ITree(void)
{
}


ITree::~ITree(void)
{
}

树A

TreeA.h

#pragma once
#include "itree.h"
class CTreeA :
    public ITree
{
public:
    CTreeA(void);
    ~CTreeA(void);
public:
    IFungus* GetFungus();
    ICannon* GetCannon();
};

TreeB.cpp

#include "TreeA.h"
#include "FungusA.h"
#include "CannonB.h";

CTreeA::CTreeA(void)
{
}


CTreeA::~CTreeA(void)
{
}

IFungus* CTreeA::GetFungus()
{
    return new CFungusA();
}

ICannon* CTreeA::GetCannon()
{
    return new CCannonB();
}

树B

TreeB.h

#pragma once
#include "itree.h"
class CTreeB :
    public ITree
{
public:
    CTreeB(void);
    ~CTreeB(void);
public:
    IFungus* GetFungus();
    ICannon* GetCannon();
};

TreeB.cpp

#include "TreeB.h"
#include "FungusB.h"
#include "CannonA.h"

CTreeB::CTreeB(void)
{
}


CTreeB::~CTreeB(void)
{
}

IFungus* CTreeB::GetFungus()
{
    return new CFungusB();
}

ICannon* CTreeB::GetCannon()
{
    return new CCannonA();
}

场景

main.cpp

#include "ITree.h"
#include "TreeA.h"
#include "TreeB.h"

int main()
{
    ITree* pTreeA = new CTreeA();
    ITree* pTreeB = new CTreeB();

    pTreeA->GetFungus()->Fight();
    pTreeA->GetCannon()->Fire();

    pTreeB->GetFungus()->Fight();
    pTreeB->GetCannon()->Fire();

    delete pTreeB;
    delete pTreeA;

    return 0;
}

如果又有了其他类型的真菌飞机和炮，我们扩展相应的类型，然后创立相应的工厂（树）进行组合生产就行了。

其实很想通过构造函数传参数，通过参数来决定生产的是什么，但是这样的话，总觉得侵入式方法破坏了工厂类的自主权，干涉了这种设计模式的目的：不用关心具体产品，只要知道哪个工厂生产什么就行。