COM原理与实现之二: 聚合

设计模式 前端之家
前端之家收集整理的这篇文章主要介绍了COM原理与实现之二: 聚合，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

COM原理与实现之二: 聚合


C++没有同聚合等价的特性。聚合实际上是继承性的一种动态形式。而C++的继承总是静态的，是实现继承。COM是接口继承，通过聚合接口，可以做成动态配置。

研究COM，主要是利用接口继承的灵活性构筑强大的系统：可配置、可插拔、可脚本化。本文不讲太多理论，详细原理参考[COM技术内幕]这本书。关于[COM技术内幕]，很多内容过时了，比如注册表，类厂之类的。我更关心COM思想所蕴含的哲学。我实现了跨平台COM，支持聚合。


GameStencil这个组件聚合了SystemMngmt这个组件。最初采用IGameStencil::getSystemMngmt()这样的形式返回一个ISystemMngmt接口指针，显然这不是聚合。通过A对象的方法得到B对象，显然A仅仅是B的一种类厂。于是我下决心解决组件聚合问题。就有了本文。


core目录下面就3个文件，是我的跨平台COM的基础。

1） Platform.h

/**
* Platform.h
*
*
* Init Created: 2016-06-10
* Last Updated: 2016-06-10
*/
#ifndef PLATFORM_H
#define PLATFORM_H

#if defined _MSC_VER || WIN32
    #ifndef OS_PLATFORM_WIN
        #define OS_PLATFORM_WIN
    #endif  
#endif

#ifdef OS_PLATFORM_WIN
    #include <windows.h>
    #include <process.h>
#else
    #include <pthread.h>
    #include <unistd.h>
#endif

#ifndef interface
#define interface struct
#endif


/**
* interface iid
*/
typedef unsigned int iid_t;


/**
* long result
*/
typedef long lresult_t;

#define lres_success             0
#define lres_error             (-1)
#define lres_e_initdata        (-2)
#define lres_e_outmemory       (-4)
#define lres_e_nointerface     (-11)
#define lres_e_noaggregation   (-12)

/**
* thread_ctx
*/
#define thread_ctx_single    0
#define thread_ctx_multiple  1


/**
* ref count type
*/
#ifdef OS_PLATFORM_WIN
    typedef volatile unsigned long refcount_t;
    #define __interlock_inc(add)  InterlockedIncrement(add)
    #define __interlock_dec(sub)  InterlockedDecrement(sub)
#else
    typedef volatile size_t refcount_t;
    #define __interlock_inc(add)  __sync_add_and_fetch(add,1)
    #define __interlock_dec(sub)  __sync_sub_and_fetch(sub,1)
#endif


#endif /* PLATFORM_H */

2） Universal.h

/**
* Universal.h
* 
* Refer:
*   <<Inside COM>>
*
* Init Created: 2016-06-10
* Last Updated: 2016-06-13
*/
#ifndef UNIVERSAL_H
#define UNIVERSAL_H

#include "Platform.h"


// IUniversal is a variant from IUnknown
//
interface IUniversal
{
    static const iid_t IID = ((iid_t) (0));

    virtual lresult_t query(iid_t iid,void **ppvOut) = 0;
    virtual unsigned long retain(void) = 0;
    virtual unsigned long release(void) = 0;
};

#define iid_IUniversal  (IUniversal::IID)


// Nondelegating IUniversal interface 
//   - Nondelegating version of IUniversal
// 
interface INondelegatingUniversal
{
    static const iid_t IID = ((iid_t) (-1));

    virtual lresult_t NondelegatingQuery(iid_t iid,void **ppvOut) = 0;
    virtual unsigned long NondelegatingRetain(void) = 0;
    virtual unsigned long NondelegatingRelease(void) = 0;
};

#define iid_INondelegatingUniversal  (INondelegatingUniversal::IID)


class UniversalImpl
{
private:
    unsigned  thread_ctx;
    refcount_t  ref_count;

public:
    UniversalImpl() :
        ref_count(1),thread_ctx(thread_ctx_multiple) {
        printf("UniversalImpl\n");
    }

    virtual ~UniversalImpl() {
        printf("~UniversalImpl\n");
    }


    void init(unsigned threadctx) {
        thread_ctx = threadctx;
    }


    // Notification to derived classes that we are releasing 
    void finalRelease() {
        // Increment reference count for final release
        ref_count = 1;
    }


    unsigned getThreadCtx() const {
        return thread_ctx;
    }


    // IUniversal
    //
    virtual lresult_t query(iid_t iid,void **ppv) = 0;


    virtual unsigned long retain(void) {
        if (thread_ctx == thread_ctx_multiple) {
            return __interlock_inc(&ref_count);
        } else {
            return ++ref_count;
        }
    }


    virtual unsigned long release(void) {
        if (thread_ctx == thread_ctx_multiple) {
            if (__interlock_dec(&ref_count) == 0) {
                delete this;
                return 0;
            }
        } else {
            if (--ref_count == 0) {
                delete this;
                return 0;
            }
        }
        return ref_count;
    }
};


// Declaration of NondelegatingUniversalImpl
//   - Base class for implementing INondelegatingUniversal
//
class NondelegatingUniversalImpl : public INondelegatingUniversal
{
public:

    virtual lresult_t NondelegatingQuery(iid_t iid,void **ppv) = 0;


    virtual unsigned long NondelegatingRetain(void) {
        if (thread_ctx == thread_ctx_multiple) {
            return __interlock_inc(&ref_count);
        } else {
            return ++ref_count;
        }
    }

    virtual unsigned long NondelegatingRelease(void) {
        if (thread_ctx == thread_ctx_multiple) {
            if (__interlock_dec(&ref_count) == 0) {
                delete this;
                return 0;
            }
        } else {
            if (--ref_count == 0) {
                delete this;
                return 0;
            }
        }
        return ref_count;
    }


    // Constructor 
    NondelegatingUniversalImpl(IUniversal* pUniversalOuter) :
            ref_count(1) {
        // Set outer_universal pointer
        if (! pUniversalOuter) {
            // Not aggregating; delegate to nondelegating IUniversal
            m_pUniversalOuter = reinterpret_cast<IUniversal*>
                (static_cast<INondelegatingUniversal*>
                (this));
        } else {
            // Aggregating; delegate to outer IUniversal
            m_pUniversalOuter = pUniversalOuter;
        }
    }


    // Destructor 
    virtual ~NondelegatingUniversalImpl() {
    }


    // Initialization (especially for aggregates) 
    void init(unsigned threadctx) {
        thread_ctx = threadctx;
    }


    // Notification to derived classes that we are releasing 
    virtual void finalRelease() {
        // Increment reference count for final release
        ref_count = 1;
    }

protected:
    // Support for delegation 
    IUniversal* getUniversalOuter() const {
        return m_pUniversalOuter;
    }


private:
    // thread context
    unsigned thread_ctx;

    // Reference count for this object
    refcount_t  ref_count;

    // Pointer to (external) outer IUniversal
    IUniversal* m_pUniversalOuter;
};


/////////////////////////////////////////////////////////// 
// 
// Delegating IUniversal 
//   - Delegates to the nondelegating IUniversal,or to the 
//      outer IUniversal if the component is aggregated. 
// 
#define DECLARE_UNIVERSAL_INTERFACE \
    virtual lresult_t query(iid_t iid,void **ppv) { \
        return getUniversalOuter()->query(iid,ppv); \
    } \
    virtual unsigned long retain(void) { \
        return getUniversalOuter()->retain(); \
    } \
    virtual unsigned long release(void) { \
        return getUniversalOuter()->release(); \
    }


#define CREATE_INSTANCE_NO_AGGREGATION(className) \
    static lresult_t createInstance(\
            unsigned threadctx,\
            IUniversal *pUniversalOuter,\
            iid_t iid,\
            void **ppv) {\
        /* cannot be aggregated */ \
        if (pUniversalOuter) {\
            return lres_e_noaggregation; \
        } \
        className * p = new className();\
        if ( ! p) {\
            return lres_e_outmemory;\
        }\
        lresult_t hr = p->init(threadctx);\
        if (hr != lres_success) {\
            p->NondelegatingRelease();\
            return hr;\
        }\
        hr = p->NondelegatingQuery(iid,ppv);\
        p->NondelegatingRelease();\
        return hr;\
    }


#define CREATE_INSTANCE_WITH_AGGREGATION(className) \
    static lresult_t createInstance(\
            unsigned threadctx,\
            IUniversal* pUniversalOuter,\
            void **ppv) {\
        className * p = new className(pUniversalOuter);\
        if ( ! p) {\
            return lres_e_outmemory;\
        }\
        lresult_t hr = p->init(threadctx);\
        if (hr != lres_success) {\
            p->release();\
            return hr;\
        }\
        hr = p->NondelegatingQuery(iid,ppv);\
        p->NondelegatingRelease();\
        return hr;\
    }


#endif /* UNIVERSAL_H */

3）SIPtr.h

/**
* SIPtr.h
*    Smart Interface Pointer
*
* Use: SIPtr<IX> spIX;
*     Do not use with IUniversal; SIPtr<IUniversal>
*       will not compile.  Instead,use IUniversalPtr. 
*
* Refer:
*   <<Inside COM>>
*
* Init Created: 2016-06-10
* Last Updated: 2016-06-10
*/
#ifndef SIPTR_H
#define SIPTR_H

#include "Universal.h"

#include <assert.h>


template <class T> class SIPtr
{
public:

    // Constructors
    SIPtr() {
        m_pI = 0;
    }


    SIPtr(T* lp) {
        m_pI = lp;
        if ( m_pI ) {
            m_pI->retain();
        }
    }


    SIPtr(IUniversal* pI) {
        m_pI = 0;
        if ( pI ) {
            pI->query(T::IID,(void **) & m_pI);
        }
    }


    // Destructor
    ~SIPtr() {
        release();
    }


    // Reset
    void release() {
        if ( m_pI ) {
            T* pOld = m_pI;
            m_pI = 0;
            pOld->release();
        }
    }


    // Attach to an existing interface (does not retain)
    void attach(T * pI) {
        if (m_pI != pI) {
            IUniversal* pOld = m_pI;

            m_pI = pI;

            if (pOld) {
                // Release the old interface
                pOld->release();
            }
        }
    }


    // Detach the interface (does not release)
    T* detach() {
        T* pOld = m_pI;
        m_pI = 0;
        return pOld;
    }

    T* get() {
        return m_pI;
    }

    // Conversion
    operator T*() {
        return m_pI;
    }


    // Pointer operations
    T& operator*() {
        assert(m_pI);
        return * m_pI;
    }


    T** operator&() {
        assert(!m_pI);
        return &m_pI;
    }


    T* operator->() {
        assert(m_pI);
        return m_pI;
    }


    // Assignment from the same interface
    T* operator=(T* pI) {
        if (m_pI != pI) {
            // Save current value
            IUniversal* pOld = (IUniversal *) m_pI;

            // Assign new value
            m_pI = pI;

            if (m_pI) {
                m_pI->retain();
            }

            if (pOld) {
                // Release the old interface
                pOld->release();
            }
        }
        return m_pI;
    }


    // Assignment from another interface
    T* operator=(IUniversal* pI) {
        // Save current value
        IUniversal* pOld = m_pI;
        m_pI = 0;

        // Query for correct interface
        if ( pI ) {
            lresult_t hr = pI->query(T::iid_interface,(void**) & m_pI);
            assert(hr == lres_success && m_pI);
        }

        if ( pOld ) {
            // Release old pointer
            pOld->release();
        } 
        return m_pI ; 
    } 

    // bool functions 
    bool operator!() {
        return m_pI ? false : true;
    }


    // Requires a compiler that supports BOOL
    operator bool() const {
        return m_pI ? true : false;
    }


    // Interface ID
    iid_t iid() {
        return T::IID;
    } 


private: 
    // Pointer variable 
    T* m_pI;
};


/**
* IUniversalPtr is a smart interface for IUniversal
*/
class IUniversalPtr
{
public:
    // Constructors
    IUniversalPtr() {
        m_pI = 0;
    }


    IUniversalPtr(IUniversal* lp) {
        m_pI = lp;
        if ( m_pI ) {
            m_pI->retain();
        }
    }


    // Destructor
    ~IUniversalPtr() {
        release();
    }


    // Reset
    void release() {
        if (m_pI) {
            IUniversal* pOld = m_pI;
            m_pI = 0;
            pOld->release();
        }
    }


    // Conversion
    operator IUniversal*() {
        return (IUniversal*) m_pI;
    }


    // Pointer operations
    IUniversal& operator*() {
        assert(m_pI);
        return *m_pI;
    }


    IUniversal** operator&() {
        assert(!m_pI);
        return &m_pI;
    }


    IUniversal* operator->() {
        assert(m_pI);
        return m_pI;
    }


    // Assignment
    IUniversal* operator=(IUniversal* pI) {
        if (m_pI != pI) {
            // Save current value
            IUniversal* pOld = m_pI;

            // Assign new value
            m_pI = pI;

            if ( m_pI ) {
                m_pI->retain();
            }

            if ( pOld ) {
                // Release the old interface
                pOld->release();
            }
        }
        return m_pI;
    }


    // Boolean functions 
    bool operator!() {
        return m_pI ? false : true;
    }


    operator bool() const {
        return m_pI ? true : false;
    }


private:
    // Pointer variable
    IUniversal* m_pI;
}; 

#endif /* SIPTR_H */

组件 GameStencil的代码：

/**
* IGameStencil.h
*
* Author: master@pepstack.com
*
* Refer:
*   http://www.richardlord.net/blog/what-is-an-entity-framework
*   http://blog.csdn.net/i_dovelemon/article/details/30250049
*   http://blog.csdn.net/zhao_92221/article/details/46629553
*   http://blog.csdn.net/ubuntu64fan/article/details/8839778
*
* Init Created: 2016-06-13
* Last Updated: 2016-06-13
*/
#ifndef IGAME_STENCIL_H
#define IGAME_STENCIL_H


#include "core/SIPtr.h"


namespace ecs {

interface IGameStencil : IUniversal {
    static const iid_t IID = ((iid_t) 0x00F000);

    virtual void update(float dt) = 0;
};

}; /* namespace ecs */

#endif /* IGAME_STENCIL_H */


/**
* GameStencil.h
*   The GameStencil class is the central point for creating
*     and managing your game state.
*
* Refer:
*   http://www.richardlord.net/blog/what-is-an-entity-framework
*   http://blog.csdn.net/i_dovelemon/article/details/30250049
*   http://blog.csdn.net/zhao_92221/article/details/46629553
*   http://blog.csdn.net/ubuntu64fan/article/details/8839778
*
* Init Created: 2016-06-12
* Last Updated: 2016-06-12
*/
#ifndef GAME_STENCIL_H
#define GAME_STENCIL_H

#include "IGameStencil.h"

#include "SystemMngmt.h"

#include <memory>
#include <vector>
using namespace std;


namespace ecs {


class GameStencil :
    public IGameStencil,public NondelegatingUniversalImpl   
{
public:
    // Creation
    //
    CREATE_INSTANCE_NO_AGGREGATION(GameStencil)


private:

    // Constructor
    GameStencil() :
        NondelegatingUniversalImpl(0),updating(false),m_pUniversalInner(0) {

        printf("GameStencil\n");

        m_pISystemMngmt = 0;
    }


    // Destructor
    virtual ~GameStencil() {
        finalRelease();

        printf("~GameStencil\n");
    }


	// Initialization
    //
	virtual lresult_t init(unsigned threadctx) {
        NondelegatingUniversalImpl::init(threadctx);

        IUniversal * pUniversalOuter = this;

        lresult_t hr = SystemMngmt::createInstance(threadctx,pUniversalOuter,IUniversal::IID,(void**) &m_pUniversalInner);

        if (hr != lres_success) {
            return lres_error;
        }

        hr = m_pUniversalInner->query(ISystemMngmt::IID,(void**) &m_pISystemMngmt);

        if (hr != lres_success) {
            m_pUniversalInner->release();
            return lres_error;
        }

        pUniversalOuter->release();
        return lres_success;
    }


    virtual void finalRelease() {
        NondelegatingUniversalImpl::finalRelease();

        getUniversalOuter()->retain();

        m_pISystemMngmt->release();

        if (m_pUniversalInner) {
            m_pUniversalInner->release();
        }
    }


    // IUniversal
    //
    DECLARE_UNIVERSAL_INTERFACE


    // INondelegatingUniversal
    //
	virtual lresult_t NondelegatingQuery(iid_t iid,void** ppv) {
        if (iid == IUniversal::IID) {
            *ppv = static_cast<IGameStencil*> (this);
        } else if (iid == IGameStencil::IID) {
            *ppv = static_cast<IGameStencil*> (this);
        } else if (iid == ISystemMngmt::IID) {
            // contained component
            *ppv = m_pISystemMngmt;
        } else {
            *ppv = 0;
            return lres_e_nointerface;
        }

        reinterpret_cast<IUniversal*> (*ppv)->retain();
        return lres_success;
    }
 
    // IGameStencil
    //
    virtual void update(float dt) {
        updating = true;

        // TODO:

        updating = false;
    }


private:
    bool updating;

    IUniversal * m_pUniversalInner;

    ISystemMngmt * m_pISystemMngmt;
};

}; /* namespace ecs */

#endif /* GAME_STENCIL_H */


被聚合的组件 SystemMngmt的代码：

/**
* ISystemMngmt.h
*
* Author: master@pepstack.com
*
* Refer:
*   http://www.richardlord.net/blog/what-is-an-entity-framework
*   http://blog.csdn.net/i_dovelemon/article/details/30250049
*   http://blog.csdn.net/zhao_92221/article/details/46629553
*   http://blog.csdn.net/ubuntu64fan/article/details/8839778
*
* Init Created: 2016-06-10
* Last Updated: 2016-06-12
*/
#ifndef ISYSTEM_MNGMT_H
#define ISYSTEM_MNGMT_H


#include "core/SIPtr.h"


namespace ecs {

interface ISystemMngmt : IUniversal
{
    static const iid_t IID = ((iid_t) 0x10F001);

    virtual void update(float dt) = 0;
    virtual void pause() = 0;
    virtual void resume() = 0;
};

}; /* namespace ecs */

#endif /* ISYSTEM_MNGMT_H */


/**
* SystemMngmt.h
*
* Refer:
*   http://www.richardlord.net/blog/what-is-an-entity-framework
*   http://blog.csdn.net/i_dovelemon/article/details/30250049
*   http://blog.csdn.net/zhao_92221/article/details/46629553
*   http://blog.csdn.net/ubuntu64fan/article/details/8839778
*
* Init Created: 2016-06-13
* Last Updated: 2016-06-13
*/
#ifndef SYSTEM_MNGMT_H
#define SYSTEM_MNGMT_H

#include "ISystemMngmt.h"


#include <memory>
#include <vector>
using namespace std;


namespace ecs {


class SystemMngmt :
    public ISystemMngmt,public NondelegatingUniversalImpl
{
public:
    // Creation
    //
	CREATE_INSTANCE_WITH_AGGREGATION(SystemMngmt)


private:

	// Constructor 
    SystemMngmt(IUniversal * pUniversalOuter) :
        NondelegatingUniversalImpl(pUniversalOuter) {
        paused = false;
        printf("SystemMngmt\n");
    }


    // Destructor
    virtual ~SystemMngmt() {
        finalRelease();
        printf("~SystemMngmt\n");
    }


    virtual lresult_t init(unsigned threadctx) {
        NondelegatingUniversalImpl::init(threadctx);
        return lres_success;
    }

public:

    // IUniversal
    //
    DECLARE_UNIVERSAL_INTERFACE


    // INondelegatingUniversal
    //
	virtual lresult_t NondelegatingQuery(iid_t iid,void** ppv) {
        if (iid == IUniversal::IID) {
            *ppv = static_cast<INondelegatingUniversal*> (this);
        } else if (iid == ISystemMngmt::IID) {
            *ppv = static_cast<ISystemMngmt*> (this);
        } else {
            *ppv = 0;
            return lres_e_nointerface;
        }
        reinterpret_cast<IUniversal*> (*ppv)->retain();
        return lres_success;
    }
 
    // ISystemMngmt
    //

    // Update all the system
    void update(float dt) {

    }

    // Pause all the systems
    void pause() {
        paused = true;
    }


    // Resume all the systems
    void resume() {
        paused = false;
    }

private:

    bool paused;
};

}; /* namespace ecs */

#endif /* SYSTEM_MNGMT_H */

最后是测试代码：

//
// main.cpp
//
#ifdef WIN32
    // Refer:
    //   http ://www.cnblogs.com/skynet/archive/2011/02/20/1959162.html
    #define _CRTDBG_MAP_ALLOC
    #include <stdlib.h>
    #include <crtdbg.h>
#else
    #include <stdlib.h>
#endif

#include <assert.h>
#include <stdio.h>
#include <string.h>

#include "model/GameStencil.h"

using namespace ecs;

void usage()
{
    SIPtr<IGameStencil> spGame;
    GameStencil::createInstance(thread_ctx_single,spGame.iid(),(void**) &spGame);

    SIPtr<ISystemMngmt> spSysMngmt;
    spGame->query(spSysMngmt.iid(),(void**) &spSysMngmt);

    SIPtr<IGameStencil> spGame2;
    spSysMngmt->query(spGame2.iid(),(void**) &spGame2);

    assert(spGame2.get() == spGame.get());

    spSysMngmt->update(0.1f);
}


int main()
{
#ifdef _CRTDBG_MAP_ALLOC
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif

    printf("main.cpp start\n");

    usage();

    printf("main.cpp exit.\n");
    return 0;
}
没有内存泄露。OK! 原文链接：https://www.f2er.com/javaschema/283825.html

猜你在找的设计模式相关文章

适配器模式-让不兼容的接口得以适配
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以相互合...
策略模式-定义一个算法族
策略模式定义了一系列算法族，并封装在类中，它们之间可以互相替换，此模式让算法的变化独...
设计模式之高质量代码
设计模式讲的是如何编写可扩展、可维护、可读的高质量代码，它是针对软件开发中经常遇到的...
模板方法模式-封装一套算法流程
模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中，使得子类可以在...
迭代器模式-统一集合的遍历方式
迭代器模式提供了一种方法，用于遍历集合对象中的元素，而又不暴露其内部的细节。
单例模式的五种实现方式及优缺点
单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。
组合模式-统一的处理个别对象与组合对象
组合模式可以将对象组合成树形结构来表示“整体-部分”的层次结构，使得客户可以用一致的方...
装饰者模式-动态的包装原有对象的行为
装饰者模式能够更灵活的，动态的给对象添加其它功能，而不需要修改任何现有的底层代码。
观察者模式-将消息通知给观察者
观察者模式（Observer Design Pattern）定义了对象之间的一对多依赖，当对象状态改变的时候...
代理模式-访问对象的代理而非其本身
代理模式为对象提供一个代理，来控制对该对象的访问。代理模式在不改变原始类代码的情况下...
算法设计模式多媒体技术正则表达式ElasticsearchFlinkHadoopIDE
受约束摘*day25Java常用类库置信lamda留存持续录入年后正则表达式303.17regularexpre匹多模适20130322基础理论pathmunge涵义reectok需要转义的特资源分享validationex简明魔法里弄形如源码实现完备actionscript