社区
学习
工具库
AI工具
休闲
搜索
简体中文
目录
3、代码分析
4、运行截图
首页 数据库 mysql教程 【2】设计模式之抽象工厂模式（AbstractFactory）

【2】设计模式之抽象工厂模式（AbstractFactory）

WBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWB
WBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWB
Jun 07, 2016 pm 03:01 PM
工厂 抽象 模式 设计模式

注释： main()，女娲 IHuman，产品接口 CYellowHuman，抽象产品之一 CYellowFemaleHuman，具体产品之一 CYellowMaleHuman，具体产品之二 CWhiteHuman，抽象产品之二 CWhiteFemaleHuman，具体产品之三 CWhiteMaleHuman，具体产品之四 CBlackHuman，抽象产品之

注释：

    main()，女娲

    IHuman，产品接口

    CYellowHuman，抽象产品之一

    CYellowFemaleHuman，具体产品之一

    CYellowMaleHuman，具体产品之二

    CWhiteHuman，抽象产品之二

    CWhiteFemaleHuman，具体产品之三

    CWhiteMaleHuman，具体产品之四

    CBlackHuman，抽象产品之三

    CBlackFemaleHuman，具体产品之五

    CBlackMaleHuman，具体产品之六

    IHumanFactory，抽象工厂

    CStandardHumanFactory，抽象工厂基类（此类可有可无）

    CFemaleHumanFactory，工厂之一

    CMaleHumanFactory，工厂之二

工程目录：

【2】设计模式之抽象工厂模式（AbstractFactory）

3、代码分析

1）Man-White

（1）WhiteHuman

//WhiteHuman.h
#ifndef __AbstractFactory__WhiteHuman__
#define __AbstractFactory__WhiteHuman__

#include "IHuman.h"

class CWhiteHuman : public IHuman
{
public:
    CWhiteHuman(void);
    ~CWhiteHuman(void);
    void Laugh();
    void Cry();
    void Talk();
    virtual void Sex() = 0;
};

#endif /* defined(__AbstractFactory__WhiteHuman__) */

//WhiteHuman.cpp
#include "WhiteHuman.h"
#include <iostream>
using std::cout;
using std::endl;

CWhiteHuman::CWhiteHuman(void)
{
    
}
CWhiteHuman::~CWhiteHuman(void)
{
    
}
void CWhiteHuman::Cry()
{
    cout （2）WhiteMaleHuman
<p></p>
<pre class="brush:php;toolbar:false">//WhiteMaleHuman.h
#ifndef __AbstractFactory__WhiteMaleHuman__
#define __AbstractFactory__WhiteMaleHuman__

#include <iostream>
#include "WhiteHuman.h"
using std::cout;
using std::endl;

class CWhiteMaleHuman : public CWhiteHuman
{
public:
    CWhiteMaleHuman(void)
    {
        
    }
    ~CWhiteMaleHuman(void)
    {
        
    }
    void Sex()
    {
        cout （3）WhiteFemaleHuman
<p></p>
<pre class="brush:php;toolbar:false">//WhiteFemaleHuman.h
#ifndef __AbstractFactory__WhiteFemaleHuman__
#define __AbstractFactory__WhiteFemaleHuman__

#include <iostream>
#include "WhiteHuman.h"
using std::cout;
using std::endl;

class CWhiteFemaleHuman : public CWhiteHuman
{
public:
    CWhiteFemaleHuman(void)
    {
        
    }
    ~CWhiteFemaleHuman(void)
    {
        
    }
    void Sex()
    {
        cout 2）Man-Black
<p>（1）BlackHuman</p>
<p></p>
<pre class="brush:php;toolbar:false">//BlackHuman.h
#ifndef __AbstractFactory__BlackHuman__
#define __AbstractFactory__BlackHuman__
#include <iostream>
#include "IHuman.h"

class CBlackHuman : public IHuman
{
public:
    CBlackHuman(void);
    ~CBlackHuman(void);
    void Laugh();
    void Cry();
    void Talk();
    virtual void Sex() = 0;
};

#endif /* defined(__AbstractFactory__BlackHuman__) */

//BlackHuman.cpp
#include "BlackHuman.h"
#include <iostream>
using std::cout;
using std::endl;

CBlackHuman::CBlackHuman(void)
{
    
}
CBlackHuman::~CBlackHuman(void)
{
    
}
void CBlackHuman::Laugh()
{
    cout （2）BlackMaleHuman<pre class="brush:php;toolbar:false">//BlackMaleHuman.h
#include <iostream>
#include "BlackHuman.h"
using std::cout;
using std::endl;

class CBlackMaleHuman : public CBlackHuman
{
public:
    CBlackMaleHuman(void)
    {
        
    }
    ~CBlackMaleHuman(void)
    {
        
    }
    void Sex()
    {
        cout （3）BlackFemaleHuman
<p></p>
<pre class="brush:php;toolbar:false">//BlackFemaleHuman.h
#ifndef __AbstractFactory__BlackFemaleHuman__
#define __AbstractFactory__BlackFemaleHuman__

#include <iostream>
#include "BlackHuman.h"
using std::cout;
using std::endl;

class CBlackFemaleHuman : public CBlackHuman
{
public:
    CBlackFemaleHuman(void)
    {
        
    }
    ~CBlackFemaleHuman(void)
    {
        
    }
    void Sex()
    {
        cout 3）Man-Yellow
<p>（1）YellowHuman<br>
</p>
<pre class="brush:php;toolbar:false">//YellowHuman.h
#ifndef __AbstractFactory__YellowHuman__
#define __AbstractFactory__YellowHuman__

#include "IHuman.h"

class CYellowHuman : public IHuman
{
public:
    CYellowHuman(void);
    ~CYellowHuman(void);
    void Laugh();
    void Cry();
    void Talk();
    virtual void Sex() = 0;
};

#endif /* defined(__AbstractFactory__YellowHuman__) */

//YellowHuman.cpp
#include "YellowHuman.h"
#include <iostream>
using std::cout;
using std::endl;

CYellowHuman::CYellowHuman(void)
{
    
}
CYellowHuman::~CYellowHuman(void)
{
    
}
void CYellowHuman::Cry()
{
    cout （2）YellowMaleHuman
<p></p>
<pre class="brush:php;toolbar:false">//YellowMaleHuman.h
#include "YellowHuman.h"
#include <iostream>
using std::cout;
using std::endl;

class CYellowMaleHuman : public CYellowHuman
{
public:
    CYellowMaleHuman(void)
    {
        
    }
    ~CYellowMaleHuman(void)
    {
        
    }
    void Sex()
    {
        cout （3）YellowFemaleHuman
<p></p>
<pre class="brush:php;toolbar:false">//YellowFemaleHuman.h
#ifndef __AbstractFactory__YellowFemaleHuman__
#define __AbstractFactory__YellowFemaleHuman__

#include "YellowHuman.h"
#include <iostream>
using std::cout;
using std::endl;

class CYellowFemaleHuman : public CYellowHuman
{
public:
    CYellowFemaleHuman(void)
    {
        
    }
    ~CYellowFemaleHuman(void)
    {
        
    }
    void Sex()
    {
        cout 4）IHuman.h
<p></p>
<pre class="brush:php;toolbar:false">#ifndef AbstractFactory_IHuman_h
#define AbstractFactory_IHuman_h

class IHuman
{
public:
    IHuman(void)
    {
        
    }
    virtual ~IHuman(void)
    {
        
    }
    virtual void Laugh() = 0;
    virtual void Cry()   = 0;
    virtual void Talk()  = 0;
    virtual void Sex()   = 0;
};

#endif
登录后复制
Factory

（1）IHumanFactory.h

#ifndef AbstractFactory_IHumanFactory_h
#define AbstractFactory_IHumanFactory_h

#include <iostream>
#include "IHuman.h"
class IHumanFactory
{
public:
    IHumanFactory(void)
    {
        
    }
    virtual ~IHumanFactory(void)
    {
        
    }
    virtual IHuman* CreateYellowHuman() = 0;
    virtual IHuman* CreateWhiteHuman() = 0;
    virtual IHuman* CreateBlackHuman() = 0;
};
#endif</iostream>
登录后复制
（2）CStandardHumanFactory 

//CStandardHumanFactory.h
#ifndef __AbstractFactory__CStandardHumanFactory__
#define __AbstractFactory__CStandardHumanFactory__

#include <iostream>
#include "IHuman.h"
#include "IHumanFactory.h"

template<class t>
class CStandardHumanFactory : public IHumanFactory
{
public:
    CStandardHumanFactory(void)
    {
        
    }
    ~CStandardHumanFactory(void)
    {
        
    }
    IHuman* CreateHuman()
    {
        return new T;
    }
};

#endif /* defined(__AbstractFactory__CStandardHumanFactory__) */

//CStandardHumanFactory.cpp
空</class></iostream>
登录后复制
（3）MaleHumanFactory.h 

//MaleHumanFactory.h

#ifndef __AbstractFactory__MaleHumanFactory__
#define __AbstractFactory__MaleHumanFactory__

#include <iostream>
#include "CStandardHumanFactory.h"
#include "IHumanFactory.h"

template<class t>
class CMaleHumanFactory : public CStandardHumanFactory<t>
{
public:
    CMaleHumanFactory(void);
    ~CMaleHumanFactory(void);
    IHuman* CreateYellowHuman();
    IHuman* CreateWhiteHuman();
    IHuman* CreateBlackHuman();
};

#endif /* defined(__AbstractFactory__MaleHumanFactory__) */

//MaleHumanFactory.cpp
#include "MaleHumanFactory.h"

template<class t>
CMaleHumanFactory<t>::CMaleHumanFactory(void)
{
    
}
template<class t>
CMaleHumanFactory<t>::~CMaleHumanFactory(void)
{
    
}
template<class t>
IHuman* CMaleHumanFactory<t>::CreateYellowHuman()
{
    return CStandardHumanFactory<t>::CreateHuman();
}
template<class t>
IHuman* CMaleHumanFactory<t>::CreateWhiteHuman()
{
    return CStandardHumanFactory<t>::CreateHuman();
}
template<class t>
IHuman* CMaleHumanFactory<t>::CreateBlackHuman()
{
    return CStandardHumanFactory<t>::CreateHuman();
}</t></t></class></t></t></class></t></t></class></t></class></t></class></t></class></iostream>
登录后复制
（4）FemaleHumanFactory 

//FemaleHumanFactory.h
#ifndef __AbstractFactory__FemaleHumanFactory__
#define __AbstractFactory__FemaleHumanFactory__

#include <iostream>
#include "CStandardHumanFactory.h"
#include "IHuman.h"

template<class t>
class CFemaleHumanFactory : public CStandardHumanFactory<t>
{
public:
    CFemaleHumanFactory(void)
    {
        
    }
    ~CFemaleHumanFactory(void)
    {
        
    }
    IHuman* CreateYellowHuman()
    {
        return CStandardHumanFactory<t>::CreateHuman();
    }
    IHuman* CreateWhiteHuman()
    {
        return CStandardHumanFactory<t>::CreateHuman();
    }
    IHuman* CreateBlackHuman()
    {
        return CStandardHumanFactory<t>::CreateHuman();
    }
    
};

#endif /* defined(__AbstractFactory__FemaleHumanFactory__) */

//FemaleHumanFactory.cpp
空</t></t></t></t></class></iostream>
登录后复制
Main.cpp 

#include <iostream>
#include <stdio.h>
#include "IHuman.h"
#include "IHumanFactory.h"
#include "FemaleHumanFactory.h"
#include "MaleHumanFactory.h"
#include "MaleHumanFactory.cpp"
#include "YellowFemaleHuman.h"
#include "YellowMaleHuman.h"
#include "WhiteFemaleHuman.h"
#include "WhiteMaleHuman.h"
#include "BlackFemaleHuman.h"
#include "BlackMaleHuman.h"

void DoMakeHuman()
{
    cout ();
    IHuman* pYellowFemaleHuman = pFemaleHumanFactory->CreateYellowHuman();
    pYellowFemaleHuman->Cry();
    pYellowFemaleHuman->Laugh();
    pYellowFemaleHuman->Talk();
    pYellowFemaleHuman->Sex();
    delete pYellowFemaleHuman;
    delete pFemaleHumanFactory;
    cout ();
    IHuman* pYellowMaleHuman = pMaleHumanFactory->CreateYellowHuman();
    pYellowMaleHuman->Cry();
    pYellowMaleHuman->Laugh();
    pYellowMaleHuman->Talk();
    pYellowMaleHuman->Sex();
    delete pYellowMaleHuman;
    delete pMaleHumanFactory;
    
    cout ();
    IHuman* pWhiteMaleHuman = pMaleHumanFactory1->CreateWhiteHuman();
    pWhiteMaleHuman->Cry();
    pWhiteMaleHuman->Laugh();
    pWhiteMaleHuman->Talk();
    pWhiteMaleHuman->Sex();
    delete pMaleHumanFactory1;
    delete pWhiteMaleHuman;
    cout ();
    IHuman* pWhiteFemaleHuman = pFemaleHumanFactory1->CreateWhiteHuman();
    pWhiteFemaleHuman->Cry();
    pWhiteFemaleHuman->Laugh();
    pWhiteFemaleHuman->Talk();
    pWhiteFemaleHuman->Sex();
    delete pFemaleHumanFactory1;
    delete pWhiteFemaleHuman;
    cout ();
    IHuman* pBlackMaleHuman = pMaleHumanFactory2->CreateBlackHuman();
    pBlackMaleHuman->Cry();
    pBlackMaleHuman->Laugh();
    pBlackMaleHuman->Talk();
    pBlackMaleHuman->Sex();
    delete pMaleHumanFactory2;
    delete pBlackMaleHuman;
    cout ();
    IHuman* pBlackFemaleHuman = pFemaleHumanFactory2->CreateBlackHuman();
    pBlackFemaleHuman->Cry();
    pBlackFemaleHuman->Laugh();
    pBlackFemaleHuman->Talk();
    pBlackFemaleHuman->Sex();
    delete pFemaleHumanFactory2;
    delete pBlackFemaleHuman;
}

int main(int argc, const char * argv[]) {

    DoMakeHuman();
    std::cout 
<h2 id="运行截图">4、运行截图</h2>
<p><img  src="/static/imghw/default1.png" data-src="pic/20151007/x254qwmpe5a.png" class="lazy" alt="【2】设计模式之抽象工厂模式（AbstractFactory）" ><br>
</p>
<p><br>
</p>
<br>
<span>参考资料：http://blog.csdn.net/rexuefengye/article/details/12704821，感谢</span>my183100521<span>博主的精彩博文。</span>


</stdio.h></iostream>
登录后复制
本站声明
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系admin@php.cn

热AI工具

Undresser.AI Undress

Undresser.AI Undress

人工智能驱动的应用程序，用于创建逼真的裸体照片

AI Clothes Remover

AI Clothes Remover

用于从照片中去除衣服的在线人工智能工具。

Undress AI Tool

Undress AI Tool

免费脱衣服图片

Clothoff.io

Clothoff.io

AI脱衣机

AI Hentai Generator

AI Hentai Generator

免费生成ai无尽的。

显示更多

热门文章

R.E.P.O.能量晶体解释及其做什么（黄色晶体）
3 周前 By 尊渡假赌尊渡假赌尊渡假赌
R.E.P.O.最佳图形设置
3 周前 By 尊渡假赌尊渡假赌尊渡假赌
刺客信条阴影：贝壳谜语解决方案
1 周前 By DDD
R.E.P.O.如果您听不到任何人，如何修复音频
3 周前 By 尊渡假赌尊渡假赌尊渡假赌
在哪里可以找到原子中的起重机控制钥匙卡
1 周前 By DDD
显示更多

热工具

记事本++7.3.1

记事本++7.3.1

好用且免费的代码编辑器

SublimeText3汉化版

SublimeText3汉化版

中文版，非常好用

禅工作室 13.0.1

禅工作室 13.0.1

功能强大的PHP集成开发环境

Dreamweaver CS6

Dreamweaver CS6

视觉化网页开发工具

SublimeText3 Mac版

SublimeText3 Mac版

神级代码编辑软件(SublimeText3)

显示更多

热门话题

gmail邮箱登陆入口在哪里
7440
15
CakePHP 教程
1370
52
steam的账户名称是什么格式
76
11
win11激活密钥永久
32
19
显示更多
Related knowledge
Java框架中设计模式与架构模式的区别 Java框架中设计模式与架构模式的区别 Jun 02, 2024 pm 12:59 PM

在Java框架中，设计模式和架构模式的区别在于：设计模式定义了在软件设计中解决常见问题的抽象解决方案，关注类和对象之间的交互，如工厂模式。架构模式定义了系统结构和模块之间的关系，关注系统组件的组织和交互，如分层架构。

Java设计模式之适配器模式的妙用 Java设计模式之适配器模式的妙用 May 09, 2024 pm 12:54 PM

适配器模式是一种结构型设计模式，允许不兼容对象协同工作，它将一个接口转换为另一个，使对象能够顺利交互。对象适配器通过创建包含被适配对象的适配器对象，并实现目标接口，实现适配器模式。在一个实战案例中，通过适配器模式，客户端（如MediaPlayer）可以播放高级格式的媒体（如VLC），尽管其本身仅支持普通媒体格式（如MP3）。

Java设计模式之装饰器模式剖析 Java设计模式之装饰器模式剖析 May 09, 2024 pm 03:12 PM

装饰器模式是一种结构型设计模式，允许动态添加对象功能，无需修改原始类。它通过抽象组件、具体组件、抽象装饰器和具体装饰器的协作实现，可以灵活扩展类功能，满足变化的需求。示例中，将牛奶和摩卡装饰器添加到Espresso，总价为2.29美元，展示了装饰器模式在动态修改对象行为方面的强大功能。

PHP 设计模式实战案例解析 PHP 设计模式实战案例解析 May 08, 2024 am 08:09 AM

1.工厂模式:分离对象创建和业务逻辑，通过工厂类创建指定类型的对象。2.观察者模式:允许主题对象通知观察者对象其状态更改，实现松耦合和观察者模式。

设计模式如何应对代码维护难题 设计模式如何应对代码维护难题 May 09, 2024 pm 12:45 PM

设计模式通过提供可重用和可扩展的解决方案来解决代码维护难题：观察者模式：允许对象订阅事件，并在事件发生时收到通知。工厂模式：提供了一种创建对象的集中式方式，而无需依赖具体类。单例模式：确保一个类只有一个实例，用于创建全局可访问的对象。

java框架中使用设计模式的优缺点有哪些？ java框架中使用设计模式的优缺点有哪些？ Jun 01, 2024 pm 02:13 PM

Java框架中使用设计模式的优点包括：代码可读性、可维护性和可扩展性增强。缺点包括：过度使用导致复杂性、性能开销以及学习曲线陡峭。实战案例：代理模式用于延迟加载对象。明智地使用设计模式可充分利用其优势并最小化缺点。

PHP设计模式：测试驱动开发实践 PHP设计模式：测试驱动开发实践 Jun 03, 2024 pm 02:14 PM

TDD用于编写高质量PHP代码，步骤包括：编写测试用例，描述预期功能并使其失败。编写代码，仅使测试用例通过，无需过分优化或详细设计。测试用例通过后，优化和重构代码以提高可读性、可维护性和可扩展性。

Guice框架中设计模式的应用 Guice框架中设计模式的应用 Jun 02, 2024 pm 10:49 PM

Guice框架应用了多项设计模式，包括：单例模式：通过@Singleton注解确保类只有一个实例。工厂方法模式：通过@Provides注解创建工厂方法，在依赖注入时获取对象实例。策略模式：将算法封装成不同策略类，通过@Named注解指定具体策略。

See all articles