【2】设计模式之抽象工厂模式（AbstractFactory）-mysql チュートリアル-php.cn

3、代码分析

4、运行截图

ホームページ

データベース

mysql チュートリアル

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

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，工厂之二

工程目录：

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ツール

ホットツール

ホットトピック

Gmailメールのログイン入り口はどこですか？

7455

CakePHP チュートリアル

1375

Steamのアカウント名の形式は何ですか

Win11 Activation Key Permanent

NYTの接続はヒントと回答です

Related knowledge

Java フレームワークにおけるデザインパターンとアーキテクチャパターンの違い Jun 02, 2024 pm 12:59 PM

Java フレームワークにおけるデザインパターンとアーキテクチャパターンの違いは、デザインパターンがソフトウェア設計における一般的な問題に対する抽象的な解決策を定義し、ファクトリパターンなどのクラスとオブジェクト間の相互作用に焦点を当てていることです。アーキテクチャパターンは、階層化アーキテクチャなどのシステムコンポーネントの編成と相互作用に焦点を当てて、システム構造とモジュールの間の関係を定義します。

Java デザインパターンにおけるデコレータパターンの分析 May 09, 2024 pm 03:12 PM

デコレータパターンは、元のクラスを変更せずにオブジェクトの機能を動的に追加できる構造設計パターンです。抽象コンポーネント、具象コンポーネント、抽象デコレータ、具象デコレータの連携によって実装され、ニーズの変化に合わせてクラス機能を柔軟に拡張できます。この例では、ミルクとモカのデコレーターが総額 2.29 ドルで Espresso に追加されており、オブジェクトの動作を動的に変更するデコレーターパターンの力を示しています。

Java 設計パターンにおけるアダプターパターンの素晴らしい使用法 May 09, 2024 pm 12:54 PM

アダプターパターンは、互換性のないオブジェクトが連携できるようにする構造設計パターンであり、オブジェクトがスムーズに対話できるように、あるインターフェイスを別のインターフェイスに変換します。オブジェクトアダプタは、適応されたオブジェクトを含むアダプタオブジェクトを作成し、ターゲットインターフェイスを実装することにより、アダプタパターンを実装します。実際のケースでは、クライアント (MediaPlayer など) はアダプターモードを通じて高度な形式のメディア (VLC など) を再生できますが、クライアント自体は通常のメディア形式 (MP3 など) のみをサポートします。

PHP設計パターンの実践事例分析 May 08, 2024 am 08:09 AM

1. ファクトリパターン: オブジェクト作成とビジネスロジックを分離し、ファクトリクラスを通じて指定された型のオブジェクトを作成します。 2. オブザーバーパターン: サブジェクトオブジェクトが状態の変化をオブザーバーオブジェクトに通知できるようにし、疎結合とオブザーバーパターンを実現します。

PHP デザインパターン: テスト駆動開発の実践 Jun 03, 2024 pm 02:14 PM

TDD は、高品質の PHP コードを作成するために使用されます。その手順には、テストケースを作成し、期待される機能を記述し、テストケースを失敗させることが含まれます。過度な最適化や詳細な設計を行わずに、テストケースのみが通過するようにコードを記述します。テストケースが合格したら、コードを最適化およびリファクタリングして、可読性、保守性、およびスケーラビリティを向上させます。

デザインパターンがコードメンテナンスの課題にどのように対処するか May 09, 2024 pm 12:45 PM

デザインパターンは、再利用可能で拡張可能なソリューションを提供することで、コードメンテナンスの課題を解決します。オブザーバーパターン: オブジェクトがイベントをサブスクライブし、イベントが発生したときに通知を受信できるようにします。ファクトリパターン: 具象クラスに依存せずにオブジェクトを作成するための集中的な方法を提供します。シングルトンパターン: クラスには、グローバルにアクセス可能なオブジェクトの作成に使用されるインスタンスが 1 つだけ存在することが保証されます。

Java フレームワークでデザインパターンを使用する利点と欠点は何ですか? Jun 01, 2024 pm 02:13 PM

Java フレームワークでデザインパターンを使用する利点には、コードの可読性、保守性、拡張性の向上が含まれます。欠点としては、複雑さ、パフォーマンスのオーバーヘッド、使いすぎによる学習曲線の急上昇などが挙げられます。実際のケース: プロキシモードはオブジェクトの遅延読み込みに使用されます。デザインパターンを賢く使用して、その利点を活用し、欠点を最小限に抑えます。

Guice フレームワークでのデザインパターンの適用 Jun 02, 2024 pm 10:49 PM

Guice フレームワークは、次のような多くの設計パターンを適用します。シングルトンパターン: @Singleton アノテーションによってクラスのインスタンスが 1 つだけであることを保証します。ファクトリメソッドパターン: @Provides アノテーションを使用してファクトリメソッドを作成し、依存関係の注入中にオブジェクトインスタンスを取得します。戦略モード: アルゴリズムをさまざまな戦略クラスにカプセル化し、@Named アノテーションを通じて特定の戦略を指定します。

See all articles

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

3、代码分析

ホットAIツール

Undresser.AI Undress

AI Clothes Remover

Undress AI Tool

Clothoff.io

AI Hentai Generator

人気の記事

ホットツール

メモ帳++7.3.1

SublimeText3 中国語版

ゼンドスタジオ 13.0.1

ドリームウィーバー CS6

SublimeText3 Mac版

ホットトピック