C++设计模式系列之一创建型模式

版权声明：此文章转载自infocool

原文链接：http://www.infocool.net/kb/CPlus/201606/159352.html

如需转载请联系听云College团队成员小尹 邮箱：yinhy#tingyun.com


1.简单工厂模式

Factory.hpp:
#ifndef _FACTORY_HPP_
#define _FACTORY_HPP_
#include <string>
class Product
{
    public:
        virtual ~Product(){}
    protected:
        Product(){}
};
class XXProduct : public Product
{
public:
    XXProduct(){}
    ~XXProduct(){}
};
class XXXProduct : public Product
{
public:
    XXXProduct(){}
    ~XXXProduct(){}
};
class Factory
{
    public:
        Factory(){}
        ~Factory(){}
        Product* CreateXXProduct()
        {
            return new XXProduct();
        }
        Product* CreateXXXProduct()
        {
            return new XXXProduct();
        }
        //或者使用枚举
        Product* CreateProduct( const char *pName )
        {
            if( strstr( pName, "XXX" ) )
            {
                return CreateXXXProduct();
            }
            else if( strstr( pName, "XX") )
            {
                return CreateXXProduct();
            }
            else
            {
                return nullptr;
            }
        }
};
#endif
Main.cpp:
#include "Factory.hpp"  
//作用:隐藏对象创建的过程  
//优点:结构简单，实现容易  
//缺点:只能创建相同类型的对象,有多少个同类型对象就要实现相应的创建方法  
int main()  
{  
    //构造一个工厂  
    Factory *pf = new Factory;  
    //隐藏创建细节,外部直接调用带参方法，或者直接调用相应的创建方法  
    Product *pxx = pf->CreateProduct( "XX" );  
    Product *pxxx = pf->CreateProduct( "XXX" );  
    delete pxx;  
    delete pxxx;
    delete pf;
    return 0;  
}

2.抽象工厂模式

AbstractFactorty.hpp:
#ifndef _ABSTRACT_FACTORY_HPP
#define _ABSTRACT_FACTORY_HPP
class XXProductA
{
public:
XXProductA(){}
virtual ~XXProductA(){}
};
class XXProductB
{
public:
XXProductB(){}
virtual ~XXProductB(){}
};
class XXProductAA : public XXProductA
{
public:
XXProductAA(){}
~XXProductAA(){}
};
class XXProductAB : public XXProductA
{
public:
XXProductAB(){}
~XXProductAB(){}
};
class XXProductBA : public XXProductB
{
public:
XXProductBA(){}
~XXProductBA(){}
};
class XXProductBB : public XXProductB
{
public:
XXProductBB(){}
~XXProductBB(){}
};
//继承关系
//XXProductAA : XXProductA
//XXProductAB : XXProductA
//XXProductBA : XXProductB
//XXProductBB : XXProductB
class AbstractFactory
{
public:
virtual ~AbstractFactory(){}
virtual XXProductA *CreateProductA() = 0;
virtual XXProductB *CreateProductB() = 0;
protected:
AbstractFactory(){}
};
//每个工厂生产不同的产品
class FactoryXA : public AbstractFactory
{
public:
FactoryXA(){}
virtual ~FactoryXA(){}
virtual XXProductA *CreateProductA()
{
return new XXProductAA();
}
virtual XXProductB *CreateProductB()
{
return new XXProductBA();
}
};
//每个工厂生产不同的产品
class FactoryXB : public AbstractFactory
{
public:
FactoryXB(){}
virtual ~FactoryXB(){}
virtual XXProductA *CreateProductA()
{
return new XXProductAB();
}
virtual XXProductB *CreateProductB()
{
return new XXProductBB();
}
};
#endif
Main.cpp:
#include "AbstractFactory.hpp"
//作用:根据不同类型的类，分为不同的创建工厂,是简单工厂模式的升级版
//优点:根据产品的不同可以分为不同的工厂，可以创建不同的类型对象
//缺点:多少个不同类型对象就要实现相应的创建方法
int main()
{
//工厂XA生产以A结尾的不同产品
AbstractFactory *pfxa = new FactoryXA;
//产品AA
XXProductA *xaa = pfxa->CreateProductA();
//产品BA
XXProductB *xba = pfxa->CreateProductB();
//工厂XB生产以B结尾的不同产品
AbstractFactory *pfxb = new FactoryXB;
//产品AB
XXProductA *xab = pfxb->CreateProductA();
//产品BB
XXProductB *xbb = pfxb->CreateProductB();
delete xbb;
delete xab;
delete pfxb;
delete xba;
delete xaa;
delete pfxa;
return 0;
}

3.Singleton模式

Singleton.cpp:
#ifndef _SINGLETON_HPP
#define _SINGLETON_HPP
template< typename T >
class Singleton
{
public:
static T& GetInstance()
{
            //当然实现singleton模式的方法很多，这里只是简单实现
            static T t;
            return t;
}
//关闭无用方法
protected:
Singleton(){}
Singleton( const Singleton &other ){}
Singleton& operator = ( const Singleton &other ){}
virtual ~Singleton(){}
};
class MyXXXManager : public Singleton< MyXXXManager >
{
    friend class Singleton< MyXXXManager >;
    private:
        MyXXXManager(){}
    public:
        ~MyXXXManager(){}
        void DoSomeThing() {}
};
#endif
Main.cpp:
#include "Singleton.hpp"
//作用:表示只能实例化一次类的对象
int main()
{
auto &Instance = MyXXXManager::GetInstance();
Instance.DoSomeThing();
return 0;
}

4.ProtoType模式

ProtoType.hpp:
#ifndef _PROTO_TYPE_HPP
#define _PROTO_TYPE_HPP
#include <memory>
class ProtoType
{
public:
virtual ~ProtoType(){}
virtual ProtoType* Clone() = 0;
protected:
ProtoType(){}
};
class XXProtoType : public ProtoType
{
public:
XXProtoType()
{
mdata = 0;
memset( mname, 0, sizeof( mname ) );
mp = new char[ 128 ];
}
XXProtoType( const XXProtoType &other )
{
mdata = other.mdata;
strcpy( mname, other.mname );
mp = new char[ 128 ];
memcpy( mp, other.mp, 128 );
}
virtual ~XXProtoType()
{
delete [] mp;
mp = nullptr;
}
virtual ProtoType* Clone()
{
//注意拷贝构造要深度拷贝
return new XXProtoType( *this );
}
private:
int mdata;
char mname[ 32 ];
char *mp;
};
#endif
Main.cpp:
#include "ProtoType.hpp"
//作用:当需要对某个对象创建相同数据的或有细微差别对象时，调用克隆方法即可,如果存在细微差别的地方通过克隆对象对外的方法调整即可
int main()
{
//创建自己
ProtoType *p = new XXProtoType;
//克隆自己
ProtoType *pClone = p->Clone();
delete pClone;
delete p;
return 0;
}
5.Builder模式
Builder.hpp:
#ifndef _BULIDER_HPP
#define _BUILDER_HPP
#include <stdio.h>
#include <memory>
typedef unsigned int u32;
typedef unsigned char u8;
typedef char c8;
//PCB板层数
enum ePcbType
{
    ePT_8 = 8,
    ePT_10 = 10,
    ePT_11 = 11,
};
//GPU类型
enum eGpuType
{
    eGT_GEFORCE_GTX_1080 = 1080,
    eGT_GEFORCE_GTX_1070 = 1070,
    eGT_GEFORCE_GTX_1060 = 1060,
};
//GPU频率
enum eGpuHz
{
    eGH_800_MHZ = 800,
    eGH_900_MHZ = 900,
    eGH_1_GHZ = 1000,
};
//显存颗粒类型
enum eMemoryType
{
    eMT_GDDR3,
    eMT_GDDR5,
    eMT_GDDR5X,
};
//显存颗粒位宽
enum eMemoryBusWidth
{
    eMBW_16BIT = 1 << 4,
    eMBW_32BIT = 1 << 5,
    eMBW_64BIT = 1 << 6,
};
//显存频率
enum eMemoryHz
{
    eMH_5000_MHZ = 5000,
    eMH_7000_MHZ = 7000,
    eMH_10_GHZ = 10000,
};
//显存颗粒
enum eMemorySize
{
    eMS_64_MB = 1 << 6,
    eMS_128_MB = 1 << 7,
    eMS_256_MB = 1 << 8,
    eMS_512_MB = 1 << 9,
    eMS_1024_MB = 1 << 10,
};
//电源类型
enum ePowerType
{
    ePWT_4PIN = 1,
    ePWT_6PIN,
    ePWT_8PIN,
};
//模拟显卡生产
class GraphicsCard
{
public:
    GraphicsCard()
    {
        memset( this, 0, sizeof( *this ) );
    }
    void Print()
    {
        const c8 *MemoryTypes[] = { "GDDR3", "GDDR5", "GDDR5X" };
        
        const c8 *PowerTypes[] = { "4PIN", "4PIN", "6PIN", "6PIN", "8PIN", "8PIN" };
        c8 PowerType[ 32 ] = {};
        for( c8 i = 0; i < sizeof( mPowerType ); ++i )
        {
            if( mPowerType[ i ] )
            {
                strcat( PowerType, PowerTypes[ i ] );
                strcat( PowerType, " " );
            }
        }
        c8 gpu_info[ 512 ] = {};
        sprintf( gpu_info,
            "显卡名称:Geforce GTX %u\n"
            "核心频率:%uMhz\n"
            "PCB层数:%u层\n"
            "显存类型:%s\n"
            "显存频率:%uMhz\n"
            "显存位宽:%ubit\n"
            "显存容量:%uMB\n"
            "电源接口:%s\n",
            mGpuType,
            mGpuHz,
            mPcbType,
            MemoryTypes[ mMemroyType ],
            mMemoryHz,
            mMemoryBushWidth,
            mMemorySize,
            PowerType
            );
        printf( "%s\n", gpu_info );
    }
    ePcbType mPcbType;
    eGpuType mGpuType;
    eGpuHz mGpuHz;
    eMemoryType mMemroyType;
    
    u32 mMemoryBushWidth;
    eMemoryHz mMemoryHz;
    u32 mMemorySize;
    u8 mPowerType[ 6 ];
};
//生产显卡流水线
class Builder
{
public:
    Builder(){}
    virtual ~Builder(){}
    virtual void SetUpPcb( ePcbType type ) = 0;                //生产pcb板
    virtual void SetUpGpu( eGpuType type, eGpuHz hz ) = 0;    //安装gpu核心
    virtual void SetUpMemory(
        eMemoryType type,            //显存颗粒类型
        eMemorySize size,            //显存颗粒容量
        eMemoryHz hz,                //出厂设置频率
        eMemoryBusWidth buswidth,    //显存颗粒位宽
        u8 count                    //安装显存颗粒数量
        ) = 0;                                                //安装显存颗粒
    virtual void SetUpPower( ePowerType type ) = 0;            //安装电源接口
    virtual GraphicsCard* GetGraphicsCard() = 0;            //得到安装完毕的显卡
};
class GraphicsBuilder : public Builder
{
    public:
        GraphicsBuilder()
        {}
        ~GraphicsBuilder()
        {}
        void SetUpPcb( ePcbType type )    //生产pcb电子板
        {
            mpGraphicsCard = new GraphicsCard;        //从开始生产pcb板开始认为是新的一块显卡,注意流程先有pcb才有下面的操作
            mpGraphicsCard->mPcbType = type;
        }
        void SetUpGpu( eGpuType type, eGpuHz hz )    //安装内核
        {
            mpGraphicsCard->mGpuType = type;
            mpGraphicsCard->mGpuHz = hz;
        }
        //安装显存颗粒
        void SetUpMemory( eMemoryType type, eMemorySize size, eMemoryHz hz, eMemoryBusWidth buswidth, u8 count )
        {
            mpGraphicsCard->mMemroyType = type;
            mpGraphicsCard->mMemoryHz = hz;
            
            mpGraphicsCard->mMemorySize = count * size;
            mpGraphicsCard->mMemoryBushWidth = count * buswidth;
        }
        //安装电源接口
        void SetUpPower( ePowerType type )
        {
            switch( type )
            {
                case ePWT_4PIN:
                    {
                        if( mpGraphicsCard->mPowerType[ 0 ] )
                        {
                            mpGraphicsCard->mPowerType[ 1 ] = type;
                        }
                        else
                        {
                            mpGraphicsCard->mPowerType[ 0 ] = type;
                        }
                    }
                    break;
                case ePWT_6PIN:
                    {
                        if( mpGraphicsCard->mPowerType[ 2 ] )
                        {
                            mpGraphicsCard->mPowerType[ 3 ] = type;
                        }
                        else
                        {
                            mpGraphicsCard->mPowerType[ 2 ] = type;
                        }
                    }
                    break;
                default:
                    {
                        if( mpGraphicsCard->mPowerType[ 4 ] )
                        {
                            mpGraphicsCard->mPowerType[ 5 ] = type;
                        }
                        else
                        {
                            mpGraphicsCard->mPowerType[ 4 ] = type;
                        }
                    }
                    break;
            }
        }
        GraphicsCard* GetGraphicsCard()
        {
            return mpGraphicsCard;
        }
    private:
        GraphicsCard *mpGraphicsCard;
};
//设计师或者是工程师
class GTX1080Engineer
{
public:
    GTX1080Engineer()
    {}
    GraphicsCard* SetUpGTX1080( Builder *p )    //GTX1080性能最好
    {
        p->SetUpPcb( ePT_11 );
        p->SetUpGpu( eGT_GEFORCE_GTX_1080, eGH_1_GHZ );
        p->SetUpMemory( eMT_GDDR5X, eMS_1024_MB, eMH_10_GHZ, eMBW_32BIT, 8 );
        p->SetUpPower( ePWT_8PIN );
        p->SetUpPower( ePWT_8PIN );
        return p->GetGraphicsCard();
    }
};
class GTX1070Engineer
{
public:
    GTX1070Engineer()
    {}
    GraphicsCard* SetUpGTX1070( Builder *p )    //GTX1070性能次之
    {
        p->SetUpPcb( ePT_10 );
        p->SetUpGpu( eGT_GEFORCE_GTX_1070, eGH_900_MHZ );
        p->SetUpMemory( eMT_GDDR5, eMS_512_MB, eMH_7000_MHZ, eMBW_32BIT, 8 );
        p->SetUpPower( ePWT_6PIN );
        p->SetUpPower( ePWT_8PIN );
        return p->GetGraphicsCard();
    }
};
class GTX1060Engineer
{
public:
    GTX1060Engineer()
    {}
    GraphicsCard* SetUpGTX1060( Builder *p )    //GTX1060性能主流
    {
        p->SetUpPcb( ePT_8 );
        p->SetUpGpu( eGT_GEFORCE_GTX_1060, eGH_800_MHZ );
        p->SetUpMemory( eMT_GDDR3, eMS_256_MB, eMH_5000_MHZ, eMBW_16BIT, 8 );
        p->SetUpPower( ePWT_8PIN );
        return p->GetGraphicsCard();
    }
};
#endif
Main.cpp:
#include "Builder.hpp"
//作用:将类的创建和数据加工进行封装我们称之为Builder设计模式( C#中的StringBuilder类为典型例子 )
//应用:地图编辑器、场景编辑器、UI编辑器( 个人理解，你自己想想是不是这样 )
//网上很多都是原话照搬，我觉得这些所谓的设计模式,要理解思想,扩展思想,将理论转换为实用和现实
//根本不可能原封不动的搬过来照用,很多人不明白为何要这样用，因为你还没
//有真正的理解这个模式，真正理解这个模式了，你就能在原有基础上，加入
//你自己的思想，用到你的项目中去,我们面对的是项目都是多种多样的,不可能
//100%的在网络上找到满足你自己的解决方案
//我认为Builder模式即:创建者模式,只要满足,创建对象并且在创建后对该对象
//数据加工进行封装即可即:XXXBuilder类封装创建和数据加工,需要创建和加工的类
//有这两个类就算是基本的Builer模式了
//我写的例子中的GTXxxxxEngineer可以省略不用,指导者，可以是类，也可以是客户程序员
//C#中的StringBuilder对字符串加工，最后返回加工后的字符串,他的指导者就是使用者或客户程序员
//下面我们通过显卡的生产来理解这个模式
int main()
{
    //显卡生产流水线
    Builder *pBuilder = new GraphicsBuilder;
    //GTX1060显卡工程师或者设计师
    GTX1060Engineer *pGTX1060Engineer = new GTX1060Engineer;
    //GTX1070显卡工程师或者设计师
    GTX1070Engineer *pGTX1070Engineer = new GTX1070Engineer;
    //GTX1080显卡工程师或者设计师
    GTX1080Engineer *pGTX1080Engineer = new GTX1080Engineer;
    //控制显卡流水线生产GTX1060显卡
    GraphicsCard *pGTX1060 = pGTX1060Engineer->SetUpGTX1060( pBuilder );
    //控制显卡流水线生产GTX1070显卡
    GraphicsCard *pGTX1070 = pGTX1070Engineer->SetUpGTX1070( pBuilder );
    //控制显卡流水线生产GTX1080显卡
    GraphicsCard *pGTX1080 = pGTX1080Engineer->SetUpGTX1080( pBuilder );
    //通过不同的显卡工程师或者设计师，我们创造了三款不同的显卡产品
    pGTX1060->Print();
    pGTX1070->Print();
    pGTX1080->Print();
    delete pGTX1060;
    delete pGTX1070;
    delete pGTX1080;
    delete pGTX1060Engineer;
    delete pGTX1070Engineer;
    delete pGTX1080Engineer;
    delete pBuilder;
    return 0;
}

想阅读更多技术文章，请访问听云技术博客，访问听云官方网站感受更多应用性能优化魔力。

关于作者

郝淼emily

重新开始，从心开始

相关日志

Java设计模式之简单工厂模式 简单工厂模式属于类的创建模式，又叫做静态工厂方法模式，它通过专门定义一个工厂类来负责创建其他类的示例，被创建的实例通常具有相同的父类或接口。
PHP之单例模式 单例模式属于创建型模式，何为创建型模式，即创建型模式抽象了实例化过程。他们帮助一个系统独立于如何创建、组合和表示他的那些对象。

我要评论

评论请先登录，或注册