#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 文件