C++设计模式系列之二结构型模式

1.Adapter模式

Adapter.hpp:

#ifndef _ADAPTER_HPP
#define _ADAPTER_HPP

//第三方库
namespace ThirdPartyNameSpace
{
class ThirdPartyClass
{
public:
ThirdPartyClass(){}
~ThirdPartyClass(){}
void ThirdPartyMethod(){}
};
};

//我们内部定义好的接口
struct IMethod
{
virtual void Method() = 0;
};

//内部实现的接口子类
class CustomMethod : public IMethod
{
public:

void Method(){}
};

//外部第三方适用我们配器实现接口统一
class ThirdPartyAdapter : public IMethod
{
public:
ThirdPartyAdapter( ThirdPartyNameSpace::ThirdPartyClass *p )
{
mp = p;
}
~ThirdPartyAdapter()
{}

void Method()
{
mp->ThirdPartyMethod();
}
private:

ThirdPartyNameSpace::ThirdPartyClass *mp;
};

#endif

Main.cpp:

#include "Adapter.hpp"

////作用:引用的第三方库方法根现有的接口不一致时，通过中间进行转换将接口保持一致( 记住这种思想即可，其实如何实现你可以自己定义 )
////缺点:当接口函数很多时,中间层不得不每一个都去实现一次，哪怕非纯虚方法,到时候
////中间层继承的接口暴露许多无用方法，这样很容易出错,感觉其实adapter是折中的方案
////既然选择第三方库了，那么项目立项的时候就要考虑进来,合理定义接口,如果是后期加入，
////第三方库一般都是独立的库，和现有接口关系不是太大,即便是有关系，也可以通过其他的方案来解决
////Adapter模式的特殊性比较强( 个人观点,不要为了设计模式而设计模式 )
//
int main()
{
//内部实现的方案1
IMethod *p = new CustomMethod;

p->Method();

//外部第三方库实现的方案2
ThirdPartyNameSpace::ThirdPartyClass *ptp = new ThirdPartyNameSpace::ThirdPartyClass;
//给内部适配器
IMethod *p2 = new ThirdPartyAdapter( ptp );

//废了这么大劲只是为了接口一致( 强烈建议自己实现满足自己项目的解决方案，有这种思想即是设计模式,当然如果该例子满足最好 )
p2->Method();

delete p2;
delete ptp;
delete p;

return 0;
}

2.Facade模式

Facade.hpp:

#ifndef _FACADE_HPP
#define _FACADE_HPP

//注意A,B,C,D 系统之间没有直接的关系
class ASystem
{
public:

ASystem(){}

~ASystem(){}

void DoSomething(){}
};

class BSystem
{
public:

BSystem(){}

~BSystem(){}

void DoSomething(){}
};

class CSystem
{
public:

CSystem(){}

~CSystem(){}

void DoSomething(){}
};

class DSystem
{
public:

DSystem(){}

~DSystem(){}

void DoSomething(){}
};

//测试ab系统模块
class TestAB
{
public:

TestAB()
{
mpa = new ASystem;
mpb = new BSystem;
}

virtual ~TestAB()
{
delete mpa;
delete mpb;
}

//外部只关心调用Test方法,A,B系统内部我们不关心，这里只做聚合功能模块
void Test()
{
mpa->DoSomething();
mpb->DoSomething();
}

private:

ASystem *mpa;
BSystem *mpb;
};

//测试cd系统模块
class TestCD
{
public:

TestCD()
{
mpc = new CSystem;
mpd = new DSystem;
}

virtual ~TestCD()
{
delete mpc;
delete mpd;
}

void Test()
{
mpc->DoSomething();
mpd->DoSomething();
}

private:

CSystem *mpc;
DSystem *mpd;
};

#endif

Main.cpp:

#include "Facade.hpp"

//作用:将我们实现的各类对象系统，抽取出来并且封装聚合在一个类中完成特定的功能
//记住这种思想即可,将各个功能类封装在另一个类中,通过这个聚合类，完成某种高级调用

int main()
{
//例如测试AB系统，我们将AB封装在TestAB用来测试A和B的调用情况外部只需要调用一个接口即可，不关心A,B的底层实现
//那么TestAB就是A和B的聚合组合，我们称之为Facade模式
TestAB *ptab = new TestAB;

//理由同上
TestCD *ptcd = new TestCD;

ptab->Test();

ptcd->Test();

delete ptcd;

delete ptab;

return 0;
}

3.Proxy模式

Proxy.hpp:

#ifndef _PROXY_HPP
#define _PROXY_HPP
#include <string>

typedef char c8;
typedef const char* cc8p;

//网络代理为典型例子( 包括但不限于例子 )
class Proxy
{
public:

Proxy(){}

~Proxy(){}

//请求代理
void ProxyLogin(
cc8p pUsr,
cc8p pPwd,
cc8p pProxyIP,
int ProxyPort,
cc8p pProxyUsr,
cc8p pProxyPwd,
cc8p pTargetIp,
int TargetPort
){}

//代理服务器回传数据
void OnProxyRecv( void *p ){}
};

class LoginUI
{
public:
LoginUI(){}
~LoginUI(){}
void OnClickedLoginBtn()
{
cc8p pUsr = "test001";
cc8p pPwd = "123456";
strcpy( mUsr, pUsr );
strcpy( mPwd, pPwd );
}
c8 mUsr[ 16 ];
c8 mPwd[ 16 ];
};

#endif

Main.cpp:

#include "Proxy.hpp"

//作用:特定的功能委托或者转交给其他对象完成，我们称之为proxy代理模式
//例如:(智能指针委托管理对象生命周期,智能锁委托管理锁对象的锁定和解锁,或者其他大部分异步调用的过程)

//下面模拟网络上最常用的网络代理
int main()
{
//登陆用户接口UI
LoginUI *pUsrInterface = new LoginUI;

//模拟用户点击登陆,得到输入的账号和密码
pUsrInterface->OnClickedLoginBtn();

//OK本地网络太卡了我们通过代理服务器连接游戏登陆服
Proxy *pProxy = new Proxy;

pProxy->ProxyLogin(
pUsrInterface->mUsr,				//用户名数据
pUsrInterface->mPwd,				//用户密码
"xxx.xxx.xxx.xxx",				//代理服务器地址
8564,							//代理服务器端口
"proxyUID",						//代理账号
"proxyPwd",						//代理密码
"xxx.xxx.xxx.xxx",				//目标服务器地址
5876							//目标服务器端口
);

//剩下的就是等待代理服务器返回数据触发pProxy->OnProxyRecv方法

delete pProxy;
delete pUsrInterface;

return 0;
}

4.Flyweight模式

Flyweight.hpp:

#ifndef _FLY_WEIGHT_HPP
#define _FLY_WEIGHT_HPP

#include <string>
#include <vector>

typedef std::string xc;

class FlyWeight
{
public:
FlyWeight(){}
~FlyWeight(){};
xc mKey;
};

class FlyWeightMgr
{
public:
FlyWeightMgr(){};
virtual ~FlyWeightMgr()
{
for( size_t i = 0; i < mFlyWeights.size(); ++i )
{
delete mFlyWeights[i];
}
mFlyWeights.clear();
};

FlyWeight* GetFlyWeight( const xc &key )
{
for( size_t i = 0; i < mFlyWeights.size(); ++i )
{
if( mFlyWeights[i]->mKey == key )
{
return mFlyWeights[i];
}
}
FlyWeight *p = new FlyWeight;
p->mKey = key;
mFlyWeights.push_back( p );
return p;
}

private:

std::vector< FlyWeight* > mFlyWeights;
};

#endif

Main.cpp:

#include "FlayWeight.hpp"

//作用:共享实例,已存在就返回，不存在就新建，然后追加到缓冲池中等待被使用
//这种模式，我们应该经常使用，只是不知道叫什么名字而已
//一般这种模式，我们会对对象的创建和销毁内部进行管理

int main()
{
//典型管理器
FlyWeightMgr *pMgr = new FlyWeightMgr;

//获取值为xfx的组件
FlyWeight *p1 = pMgr->GetFlyWeight("xfx");
FlyWeight *p2 = pMgr->GetFlyWeight("xfx");

//这两个值必然相等为true
bool b = p1 == p2;

delete pMgr;
return 0;
}

5.Bridge模式

Bridge.hpp:

#ifndef _BRIDGE_HPP
#define _BRIDGE_HPP
//移动
class Move
{
public:
Move(){}
virtual ~Move(){}
virtual void move() = 0;
};

//地面单位移动
class LandMove : public Move
{
public:
LandMove(){}
~LandMove(){}
void move(){}
};

//空中单位移动
class AirMove : public Move
{
public:
AirMove(){}
~AirMove(){}
void move(){}
};

class Unit
{
public:
Unit( Move *p )
{
mp = p;
}
virtual ~Unit(){}
virtual void move()
{
mp->move();
}
//...其他方法
protected:
Move *mp;

//...其他属性
};

//scv 地面单位
class SCV : public Unit
{
public:
SCV( Move *p )
:Unit( p )
{}
~SCV(){}
};

//坦克 地面单位
class Tank : public Unit
{
public:
Tank( Move *p )
:Unit( p )
{}
virtual ~Tank(){}
};

//维京 空中单位
class Viking : public Unit
{
public:
Viking( Move *p )
:Unit( p )
{}
~Viking(){}
};

//渡鸦 空中单位
class Raven : public Unit
{
public:
Raven( Move *p )
:Unit( p )
{}
~Raven(){}
};

#endif

Main.cpp:

#include "Bridge.hpp"

//作用:将本来录属于对象的行为，单独抽象出来成类，通过接口提供
//这样做的好处是，可以降低耦合，当行为发生改变时，原来的对象我们根本不用去管
//例如星际争霸2中的单位例子:

int main()
{
//地面单位移动算法，需要检测碰撞什么的
Move *pLandMove = new LandMove;
Unit *pScv = new SCV( pLandMove );
Unit *pTank = new Tank( pLandMove );

//空中单位移动算法，基本不需要检测地图碰撞
Move *pAirMove = new AirMove;
Unit *pViking = new Viking( pAirMove );
Unit *pRaven = new Raven( pAirMove );

pScv->move();
pTank->move();

pViking->move();
pRaven->move();

delete pScv;
delete pTank;
delete pViking;
delete pRaven;

delete pLandMove;
delete pAirMove;

return 0;
}

6.Decorator模式

Decorator.hpp:

#ifndef _DECORATOR_HPP
#define _DECORATOR_HPP
#include <stdio.h>

class Component
{
public:
Component(){}
virtual ~Component(){}
virtual void Operate(){}
};

//默认的职责,只有文件压缩
class File7z : public Component
{
public:
File7z(){}
~File7z(){}
virtual void Operate()
{
printf( "7z文件压缩中...\n" );
}
};

class Algorithm : public Component
{
public:
Algorithm( Component *p )
{
mp = p;
}
virtual ~Algorithm()
{
delete mp;
}
protected:
//上一个操作对象
Component *mp;
};

class AES256 : public Algorithm
{
public:
AES256( Component *p )
:Algorithm( p )
{}
~AES256(){}
virtual void Operate()
{
//上一个职责
mp->Operate();
printf( "aes256加密中..\n" );
}
};

class CheckError : public Algorithm
{
public:
CheckError( Component *p )
:Algorithm( p )
{}
~CheckError(){}
virtual void Operate()
{
//上一个职责
mp->Operate();
printf( "检测文件包是否出错中...\n" );
}
};

#endif

Main.cpp:

#include "Decorator.hpp"

//作用:给一个对象的行为添加新的职责，两两直接可以相互组合成新的职责，而不用在定义新的组合功能类
//例如文件压缩过程 压缩->加密->检测 等等例子可能不是太恰当，记住这种添加职责的思想即可
int main()
{
    //默认只有文件压缩
    Component *pFile7z = new File7z;

    //给pFile7z添加加密
    Component *pAes256 = new AES256( pFile7z );

    //给pFile7z加密后检测是否出错
    Component *pCheck = new CheckError( pAes256 );

    //执行
    pCheck->Operate();
    delete pCheck;
    
    //或者直接链式操作
    printf( "----\n" );
    pCheck = new CheckError( new AES256( new File7z ) );
    pCheck->Operate();

    delete pCheck;
    return 0;
}