常用设计模式

1.工厂模式
基础工厂，基础工厂提供接口来创建一系列对象．
派生类工厂，提供符合自身特性的创建方法实现．

class IClient;
class IServer;
class IFactory{
public:
    IClient* CreateClient();
    IServer* CreateServer();
    void DestroyClient(IClient*);
    void DestroyServer(IServer*);
};

IFactory* CreateFactory(int nTag){
    switch (nTag)
    {
        ...
    }
}

2.原型模式
我们要创建一个新对象p基于某个已有对象q，再加上额外的一些修改．
q可称为p的原型．

class Factory{
public:
    Factory(IClient* pClientProto){
        m_pProto = pClientProto;
    }
    IClient* CreateClient(){
        IClient* pNew = m_pProto->Clone();
        ...
        return pNew;
    }
private:
    IClient* m_pProto;
};

3.单例模式
需要获取对象

class Factory{
public:
    static Factory* Get(){
        if(s_ins == nullptr){
            s_ins = new Factory();
        }
        return s_ins;
    }
private:
    Factory(){}
public:
    static Factory* s_ins;
};

Factory* Factory::s_ins = nullptr;

4.适配器
我们的类型需要定义某些接口实现，已有类型p可对此提供支持．
以标准库的stack为例．stack可以包含一个list类型字段．基于list实例来得到自身的接口实现．
5.组合
用类似递归的思想，构建复杂的多层次模型．

class Geometry 
{
public:
    Geometry();
    virtual ~Geometry();
    virtual void Draw(NTransform::Transform* pTrans_, QPainter& painter);
    virtual GEOMETRY_TYPE GetType(){return GEOMETRY_GEOMETRY;}
};
class GeometryPoint : public Geometry
{
	...
};
class GeometryLine : public Geometry
{
	...
};
...
class GeometryGroup : public Geometry
{
	...
    NDataStruct::DynArray<Geometry*> m_arrGeometrys;
};

6.享元
在网络服务端场景，需要频繁执行被动连接分配和回收．如果用连接池存储暂时释放的被动连接，后续需要时，先从连接池获取，获取不到再创建．这样使得每个创建出的连接对象可被复用．这就是享元．

class Connect{
public:
    Connect* m_lpNext;
};
class ConnPool{
public:
    Connect* Get(){
        if(m_pList == nullptr){
            Connect* pNew = new Connect();
            return pNew;
        }else{
            Connect* pConn = m_pList;
            m_pList = m_pList->m_lpNext;
            pConn->m_lpNext = nullptr;
            return pConn;
        }
    }
    void Release(Connect* pConn){
        if(m_pList){
            pConn->m_lpNext = m_pList;
            m_pList = pConn;
        }else{
            m_pList = pConn;
        }
    }
    Connect* m_pList;
};
class Server{
public:
    Connect* GetConnect(){ return m_pPool.Get();};
    void ReleaseConnect(Connect* lpConn){
        m_pPool.Release(lpConn);
    }
private:
    ConnPool m_pPool;
};

7.责任链
类似zk的请求处理过程．每个请求需依次经历请求前期合法性检测，预先修改，请求持久化，请求落地多个阶段才能完成实际处理．这样将一个任务分解为多个阶段，每个阶段执行特定类型处理的方式就是责任链．
8.迭代器
标准库中将容器类型的基于位置访问和设置位置下元素，基于位置前后迭代的操作抽象出来成为一个独立的类型的方式就是迭代器．
9.策略
算法设计中，依据不同场景，选择不同解决算法．将每种解决算法抽象为一种类型．同类型算法拥有共同基类的方式叫策略．