COM原理与实现之二: 聚合

最新推荐文章于 2017-11-16 16:19:00 发布
最新推荐文章于 2017-11-16 16:19:00 发布
阅读量6.5k 收藏 1
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ubuntu64fan/article/details/51661430
版权

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,\
            iid_t iid,\
            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, 0, 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!


车斗
关注
专栏目录
com组件聚合
zqlnuclear的博客
07-04 200
com组件聚合
以太网链路聚合原理及实现（二层交换机下）
m0_51160032的博客
08-11 1289
目录 一、上期回顾 二、链路聚合技术原理 三、链路聚合实现条件 四、链路聚合的分类 五、二层交换机链路聚合实例 六、总结 一、上期回顾 在前两篇文章中，我们知道了单臂路由技术和三层交换机技术的概念 单臂路由技术:当只有二层交换机时，又要实现不同vlan间通信时，需要用到单臂路由技术。 三层交换实现不同vlan间路由: 三层交换机可以配置vlanif接口，通过vlanif接口可以配置ip地址，成为不同vlan 对应的网关，从而实现不同vlan间路由 二、链路聚合技术原理 ...
{C++} COM 组件多层聚合嵌套原理
weixin_34356138的博客
11-16 158
　这个小Demo是控制台调用三个动态链接库的，每个链接库中都有一个方法，最外面的库CompB.dll里面是减法运算， 聚合CompC.dll里面的乘法，CompC.dll聚合CompA.dll里面的加法。CompB.dll调用接口是OtherInterface，CompC.dll 调用接口是AnyInterface，CompA.dll调用接口是Som...
COM组件聚合例子
06-29
这个一个演示COM组件的实现与调用的例子
COM聚合
09-01 173
COM聚合... 1 聚合的概念... 1 内部组件的实现... 2 外部组件的实现... 14 ATL7对内部组件的支持... 33 分析：... 54 DECLARE_CLASSFACTORY()宏-------------55 DECLARE_AGGREGATABLE(T)宏---------------------87 ATL7对外部组件的支持... 9...
COM聚合的实现
大数据时代的狂欢
01-11 691
聚合指的是COM对象转接客户端对某个接口的请求。某COM对象B并不实现ISomeInterface接口，但是可以通过调用某个内部COM对象A来支持该接口。意思是指，当客户端调用B所支持的接口IOtherInterface查询ISomeInterface时，直接将对象A的ISomeInterface接口指针传出去。实现聚合的关键是COM对象在被聚合时的QueryInterface的处理。按照
COM 的聚合
09-18 490
 今天看了一会COM的聚合 写下心得。说得有点通俗。 先说下聚合的定义：就是一个组件A只实现了IX接口，在A内部又可以使用B组建的IY接口。如果我是客户，使用组件A， 俺既可以掉IX接口，又可以掉IY接口，我可不知道有组件B的存在哦。 聚合不能象包容那样 直接转发B对IY接口的请求，因为包容A组建实现了IY：A和B共用一套QueryInterface（）；聚合就有2套QueryIn
LTE教程原理与实现（增强版)
07-15
这个“LTE教程原理与实现（增强版）”的资料，旨在深入浅出地介绍LTE的核心概念、工作原理以及实际部署中的关键技术。 LTE的主要目标是提供比3G网络更高的数据速率，更低的延迟，更高的系统容量以及更优化的网络...
最简单的COM实现 - 聚合实现
06-26
以下是一些关于实现聚合的重要点： 1. **外壳对象的`IUnknown`**: 外壳对象的`IUnknown`必须负责管理内核对象的引用计数。在`AddRef`和`Release`方法中，需要递增或递减内核对象的引用计数。 2. **`QueryInterface...
mysql连续聚合原理与用法实例分析
09-08
- **年初至今（Year-to-Date, YTD）**：YTD聚合关注的是从年初到当前时间点的累计值，它可以反映当前状态与年初相比的变化。 3. 使用方法： 在MySQL中，可以使用`GROUP BY`子句配合日期函数，如`DATE_FORMAT()`，对...
COM 组件聚合小示例
07-03
COM原理与应用中COM聚合小示例，具体解释说明详见博客.
windows com 组件 包容、聚合实例
07-22
windows com 组件 包容、聚合实例
ATL 实现com的聚合
FrankieWang008的专栏
06-11 3476
com聚合是包容的一种特例，目的是最大化的实现功能模块话，降低组件间的耦合性。 第一步：          通过ATL创建com外部组件TestOutCom.dll，在其内部创建接口包装类CCMyOuterCom,并实现其对应的接口ICMyOuterCom                 之后点击“完成”；并在接口中实现“GetOuterMethord”方法，方便
COM聚合（转）
wilsonany的专栏
09-13 430
<br />聚合的概念<br />聚合源自组件重用。当有两个组件A和B，他们分别实现了自己的接口IA和IB。如果有一个客户程序创建了A对象使得自己可以调用IA的方法，但同时又想获得IB的接口，调用IB的方法。这时候有两种做法：一种是客户程序创建B对象，还有一种方法是A组件内部创建B组件，然后客户通过某种途径调用B的接口方法。<br />第一种方法，使得客户必须知道有独立的B组件的存在，第二种方法客户可以认为只有一个组件A，组件A实现了两个接口IA和IB。第二种方法可以制造出一种假象，让客户程序编写更加简单。
com学习4——聚合
weixin_30785593的博客
05-03 164
聚合在com中的作用非常大，它是代码重用中最有效的模型。但是聚合也是比较麻烦的，因为跟包含一样，com对象B要屏蔽掉com对象A，即用户根本不知道com对象A的存在。但是用户却直接使用了com对象A的接口，通过接口的queryinterface函数是可以查找到com对象实现的所有接口，因为用户只知道com对象B的存在，对于用户来说，通过接口的queryinterface查询的结果应该都是com对象...
COM 对象聚合
dasgk的专栏
05-28 1220
无论是对象聚合或是对象包容，其作用都是组件的复用，使用环境是这样的，有组件some对象和other对象，我们暴露出来的是some对象，现在需求改变了，some要加入新 的功能，而该功能已经被other组件对象实现，而且完全不需要修改,在这种情况下，使用对象聚合，即，首先获得Isome的接口，使用其功能，在Isome接口中使用 QueryInterface函数，获得Iother接口，进而复用其功
COM技术内幕学习笔记---第八章---组件复用：包容和聚合
shb8845369的专栏
04-08 1965
COM 不支持实现继承的原因在于这种继承方式将 使得一个对象的实现同另外一个对象的实现紧紧地关联起来。 在这种情况下，当基类的实现被修改之后，派生类将无法正常运行而必须被修改。对于一个中等规模的C++程序而言，这或许并不成为一个问题，因在这种情况下，我们一般能够获取所有的源代码，因此也将能够对派生类进行修改。但是对于较大的C++程序而言，对受影响的派生类进行修改所花费的时间将是相当长的。更糟的是
COM技术内幕中聚合的实现
Meuck的专栏
06-29 2309
1.　产生的时候，会把要用到的的相关接口指针      与的指针保存下来。2. 调用的工厂方法创建，将返回一个指针。　通过得到真实的3.在产生的时候保存IUnknown接口指针,当客户调用IUnknown的接口的时候   则转接到的接口上。而真正的IUnknown的操作而在上实现4.导出后，客户在使用IUnknown还是认为在使用　因为以把相关操作转发过来了。5.在析构的时候，则调用内部组件的进行
数据库原理：聚合函数与数据管理
"这篇PPT主要讲解了数据库原理中的聚合函数以及数据库系统的基本概念和性质。聚合函数是SQL中用于处理数据集合的重要工具，包括COUNT、SUM、AVG、MAX和MIN五种，分别用于计算元组数量、求和、求平均值、找出最大值和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

车斗

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值