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

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;
}