抽象工厂模式 C++实现的简单易懂的范例推荐给大家

#pragma once
/*
//说明：抽象产品和具体产品对象类
//文件：Product.h
//日期：2020/6/23
//作者：coder
//QQ：375187588
//修改：2020/6/30
//版本：
*//

//抽象工厂模式可以产生一系列产品
//商务车
class IBusinessCarBase
{
public:
    IBusinessCarBase() {}
    virtual~IBusinessCarBase() {}
    virtual void Create() = 0;
};

//民用车
class ICivilCarBase
{
public:
    ICivilCarBase() {}
    virtual~ICivilCarBase() {}
    virtual void Create() = 0;
};

//跑车
class ISportCarBase
{
public:
    ISportCarBase() {}
    virtual~ISportCarBase() {}
    virtual void Create() = 0;
};

class IEngine
{
public:
    virtual void Create() = 0;
    virtual ~IEngine() {};
};

class IChassis
{
public:
    IChassis() {}
    virtual void Create() = 0;    
    virtual ~IChassis() {};
};

class IWheel
{
public:
    virtual void Create() = 0;
    IWheel() {}
    virtual ~IWheel() {};
};

class CBMWEngine : public IEngine
{
public:
    CBMWEngine() {}
    ~CBMWEngine() {}
    void Create()
    {
        std::cout << "CBMWEngine!" << std::endl;
    }
};

class CBMWChassis : public IChassis
{
public:
    CBMWChassis() {}
    ~CBMWChassis() {}
    void Create()
    {
        std::cout << "CBMWChassis!" << std::endl;
    }
};

class CBMWWheel : public IWheel
{
public:
    CBMWWheel() {}
    ~CBMWWheel() {}
    void Create()
    {
        std::cout << "CBMWWheel!" << std::endl;
    }
};

class CBenzEngine : public IEngine
{
public:
    CBenzEngine() {}
    ~CBenzEngine() {}
    void Create()
    {
        std::cout << "CBenzEngine!" << std::endl;
    }
};

class CBenzChassis : public IChassis
{
public:
    CBenzChassis() {}
    ~CBenzChassis() {}
    void Create()
    {
        std::cout << "CBenzChassis!" << std::endl;
    }
};

class CBenzWheel : public IWheel
{
public:
    CBenzWheel() {}
    ~CBenzWheel() {}
    void Create()
    {
        std::cout << "CBenzWheel!" << std::endl;
    }
};

class CBMWBusinessCar : public IBusinessCarBase
{
public:
    CBMWBusinessCar(IEngine* pEngine, IChassis* pChassis, IWheel* pWheel)
    {
        m_pEngine.reset(pEngine);
        m_pChassis.reset(pChassis);
        m_pWheel.reset(pWheel);
    }
    ~CBMWBusinessCar() { std::cout << "CBMWBusinessCar 析构了!" << std::endl; }

    void Create()
    {
        std::cout << "CBMWBusinessCar开始生产！" << std::endl;
        m_pEngine.get()->Create();
        m_pChassis.get()->Create();
        m_pWheel.get()->Create();
        std::cout << "CBMWBusinessCar生产成功！" << std::endl;
    }

private:
    std::shared_ptr<IEngine> m_pEngine;
    std::shared_ptr<IChassis> m_pChassis;
    std::shared_ptr<IWheel> m_pWheel;
};

class CBMWCivilCar : public ICivilCarBase
{
public:
    CBMWCivilCar(IEngine* pEngine, IChassis* pChassis, IWheel* pWheel)
    {
        m_pEngine.reset(pEngine);
        m_pChassis.reset(pChassis);
        m_pWheel.reset(pWheel);
    }
    ~CBMWCivilCar() { std::cout << "CBMWCivilCar 析构了!" << std::endl; }

    void Create()
    {
        std::cout << "CBMWCivilCar开始生产！" << std::endl;
        m_pEngine.get()->Create();
        m_pChassis.get()->Create();
        m_pWheel.get()->Create();
        std::cout << "CBMWCivilCar生产成功！" << std::endl;
    }

private:
    std::shared_ptr<IEngine> m_pEngine;
    std::shared_ptr<IChassis> m_pChassis;
    std::shared_ptr<IWheel> m_pWheel;
};

class CBMWSportCar : public ISportCarBase
{
public:
    CBMWSportCar(IEngine* pEngine, IChassis* pChassis, IWheel* pWheel)
    {
        m_pEngine.reset(pEngine);
        m_pChassis.reset(pChassis);
        m_pWheel.reset(pWheel);
    }
    ~CBMWSportCar() { std::cout << "CBMWSportCar 析构了!" << std::endl; }

    void Create()
    {
        std::cout << "CBMWSportCar开始生产！" << std::endl;
        m_pEngine.get()->Create();
        m_pChassis.get()->Create();
        m_pWheel.get()->Create();
        std::cout << "CBMWSportCar生产成功！" << std::endl;
    }

private:
    std::shared_ptr<IEngine> m_pEngine;
    std::shared_ptr<IChassis> m_pChassis;
    std::shared_ptr<IWheel> m_pWheel;
};

class CBenzBusinessCar : public IBusinessCarBase
{
public:
    CBenzBusinessCar(IEngine* pEngine, IChassis* pChassis, IWheel* pWheel)
    {
        m_pEngine.reset(pEngine);
        m_pChassis.reset(pChassis);
        m_pWheel.reset(pWheel);
    }
    ~CBenzBusinessCar() { std::cout << "CBenzBusinessCar 析构了!" << std::endl; }

    void Create()
    {
        std::cout << "CBenzBusinessCar开始生产！" << std::endl;
        m_pEngine.get()->Create();
        m_pChassis.get()->Create();
        m_pWheel.get()->Create();
        std::cout << "CBenzBusinessCar生产成功！" << std::endl;
    }

private:
    std::shared_ptr<IEngine> m_pEngine;
    std::shared_ptr<IChassis> m_pChassis;
    std::shared_ptr<IWheel> m_pWheel;
};

class CBenzCivilCar : public ICivilCarBase
{
public:
    CBenzCivilCar(IEngine* pEngine, IChassis* pChassis, IWheel* pWheel)
    {
        m_pEngine.reset(pEngine);
        m_pChassis.reset(pChassis);
        m_pWheel.reset(pWheel);
    }
    ~CBenzCivilCar() { std::cout << "CBenzCivilCar 析构了!" << std::endl; }

    void Create()
    {
        std::cout << "CBenzCivilCar开始生产！" << std::endl;
        m_pEngine.get()->Create();
        m_pChassis.get()->Create();
        m_pWheel.get()->Create();
        std::cout << "CBenzCivilCar生产成功！" << std::endl;
    }

private:
    std::shared_ptr<IEngine> m_pEngine;
    std::shared_ptr<IChassis> m_pChassis;
    std::shared_ptr<IWheel> m_pWheel;
};

class CBenzSportCar : public ISportCarBase
{
public:
    CBenzSportCar(IEngine* pEngine, IChassis* pChassis, IWheel* pWheel)
    {
        m_pEngine.reset(pEngine);
        m_pChassis.reset(pChassis);
        m_pWheel.reset(pWheel);
    }
    ~CBenzSportCar() { std::cout << "CBenzSportCar 析构了!" << std::endl; }

    void Create()
    {
        std::cout << "CBenzSportCar开始生产！" << std::endl;
        m_pEngine.get()->Create();
        m_pChassis.get()->Create();
        m_pWheel.get()->Create();
        std::cout << "CBenzSportCar生产成功！" << std::endl;
    }

private:
    std::shared_ptr<IEngine> m_pEngine;
    std::shared_ptr<IChassis> m_pChassis;
    std::shared_ptr<IWheel> m_pWheel;
};

///-------------------------------------------------------------------
//增加一种新的车型 房车 //
//跑车
class IRoomCarBase
{
public:
    IRoomCarBase() {}
    virtual~IRoomCarBase() {}
    virtual void Create() = 0;
};

class CBenzRoomCar : public IRoomCarBase
{
public:
    CBenzRoomCar(IEngine* pEngine, IChassis* pChassis, IWheel* pWheel)
    {
        m_pEngine.reset(pEngine);
        m_pChassis.reset(pChassis);
        m_pWheel.reset(pWheel);
    }
    ~CBenzRoomCar() { std::cout << "CBenzRoomCar 析构了!" << std::endl; }

    void Create()
    {
        std::cout << "CBenzRoomCar开始生产！" << std::endl;
        m_pEngine.get()->Create();
        m_pChassis.get()->Create();
        m_pWheel.get()->Create();
        std::cout << "CBenzRoomCar生产成功！" << std::endl;
    }

private:
    std::shared_ptr<IEngine> m_pEngine;
    std::shared_ptr<IChassis> m_pChassis;
    std::shared_ptr<IWheel> m_pWheel;
};
 

#pragma once
#include "Product.h"
/*
//说明：抽象工厂模式类
//文件：Factory.h
//日期：2020/6/23
//作者：coder
//QQ：375187588
//修改：2020/6/30
//版本：
*//

class IAbstractFactor
{
public:
    virtual IBusinessCarBase* CreateBusinessCar() = 0;
    virtual ICivilCarBase* CreateCivilCar() = 0;
    virtual ISportCarBase* CreateSportCar() = 0;
};

class CBMWFactor : public IAbstractFactor
{
public:
    IBusinessCarBase* CreateBusinessCar()
    {
        return new CBMWBusinessCar(new CBMWEngine, new CBMWChassis, new CBMWWheel);
    }
    ICivilCarBase* CreateCivilCar()
    {
        return new CBMWCivilCar(new CBMWEngine, new CBMWChassis, new CBMWWheel);
    }
    ISportCarBase* CreateSportCar()
    {
        return new CBMWSportCar(new CBMWEngine, new CBMWChassis, new CBMWWheel);
    }
    ~CBMWFactor()
    {
        std::cout << "CBMWFactor 析构!" << std::endl;
    }
};

class CBenzFactor : public IAbstractFactor
{
public:
    ~CBenzFactor()
    {
        std::cout << "CBenzFactor 析构!" << std::endl;
    }
    IBusinessCarBase* CreateBusinessCar()
    {
        return new CBenzBusinessCar(new CBenzEngine, new CBenzChassis, new CBenzWheel);
    }
    ICivilCarBase* CreateCivilCar()
    {
        return new CBenzCivilCar(new CBenzEngine, new CBenzChassis, new CBenzWheel);
    }
    ISportCarBase* CreateSportCar()
    {
        return new CBenzSportCar(new CBenzEngine, new CBenzChassis, new CBenzWheel);
    }
};
/*---------------------------------------
IAbstractFactor                        -    返回 依赖        IBusinessCarBase
-+CreateBusinessCar():IBusinessCarBase    - - - - - ->    +Create():void
-                                        -
-+CreateCivilCar():ICivilCarBasei        -返回 依赖        ICivilCarBase
-                                        - - - - - ->    +Create():void
--                                        -
-                                        -返回 依赖        ISportCarBase
-+CreateSportCar():ISportCarBase        -- - - - - ->    +Create():void
----------------------------------------

*/

///
//增加一种房车生产车间
class IAbstractFactorEx : public IAbstractFactor
{
public:
    virtual IRoomCarBase* CreateRoomCar() = 0;
};

//增加一种大奔房车
class CBenzFactorEx : public IAbstractFactorEx
{
public:
    IBusinessCarBase* CreateBusinessCar()
    {
        return m_factor.CreateBusinessCar();
    }
    ICivilCarBase* CreateCivilCar()
    {
        return m_factor.CreateCivilCar();
    }
    ISportCarBase* CreateSportCar()
    {
        return m_factor.CreateSportCar();
    }
    IRoomCarBase* CreateRoomCar()
    {
        return new CBenzRoomCar(new CBenzEngine, new CBenzChassis, new CBenzWheel);
    }

private:
    //组合进行扩展 优先使用组合，而不是继承
    CBenzFactor m_factor;
};

//组合负责它的所有局部类的生命周期
//聚合它不负责局部类的生命周期

//最终目的：
//高内聚：责任要单一
//低耦合：类与类之间的变化要尽量少 能单向依赖千万不要去双向依赖

// 抽象工厂模式.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

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

void TestAbstractFactor()
{
    IBusinessCarBase *pBusCar = nullptr;
    ICivilCarBase *pCiCar = nullptr;
    ISportCarBase *pSportCar = nullptr;
    //增加的房卡车
    IRoomCarBase *pRoomCar = nullptr;
    CBMWFactor bmw;
    CBenzFactorEx benz;

    pBusCar = bmw.CreateBusinessCar();
    pBusCar->Create();
    delete pBusCar;

    pCiCar = bmw.CreateCivilCar();
    pCiCar->Create();
    delete pCiCar;

    pSportCar = bmw.CreateSportCar();
    pSportCar->Create();
    delete pSportCar;

    pBusCar = benz.CreateBusinessCar();
    pBusCar->Create();
    delete pBusCar;

    pCiCar = benz.CreateCivilCar();
    pCiCar->Create();
    delete pCiCar;

    pSportCar = benz.CreateSportCar();
    pSportCar->Create();
    delete pSportCar;

    pRoomCar = benz.CreateRoomCar();
    pRoomCar->Create();
    delete pRoomCar;
}

int main()
{
    std::cout << "Hello World!\n";
    TestAbstractFactor();
    getchar();
    return 0;
}

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件