国产综合色产,你懂的国产精品,国产精品一区二区你懂得

ATL�Ҏ(gu��)��口查询的支持

michael — Mon, 30 Apr 2007 03:37:00 GMT

COM对象实现接口的方法是多种多样的，常用的有多重�l�承、聚合、tear-off�{�。�ؓ了最大限度地支持接口查询的多��h��，ATL使用表驱动的方式来管理接口查询，以做��C��码封闭和扩展灉|��Q�表条目格式为：

struct _ATL_INTMAP_ENTRY
{
     const IID * piid;
    DWORD_PTR dw;
    _ATL_CREATORARGFUNC * pFunc;
};

piid是接口ID�Q�dw��定义参数�Q�pFunc是自定义函数的地址。在QueryInterface�Ӟ��ATL调用pFunc�Q��ƈ��dw传给pFunc�Q�pFunc可以�Ҏ(gu��)��自己的需要解析dw�Q�获得查询必需的信息。ATL预提供了一些函数来处理上述常用的查询请求，如_Creator、_Delegate�{�，它们被放�|�于CComObjectRootBase中�?br />

�Q?�Q�多重��?br /> ATL�q�没有提供支持多重��承的函数�Q�而是��pFunc讄��为_ATL_SIMPLEMAPENTRY宏，��dw设�ؓ父类子对象在子类对象中的偏移量，当搜索表时发现pFunc为_ATL_SIMPLEMAPENTRY�Ӟ��便直接��用偏�U�量相加获得�l�果�?/p>

            if (pEntries -> pFunc == _ATL_SIMPLEMAPENTRY)
            {
                IUnknown * pUnk = (IUnknown * )((INT_PTR)pThis + pEntries -> dw);
                pUnk -> AddRef();
                 * ppvObject = pUnk;
                 return S_OK;
            }

接口映射表项宏�ؓ�Q?/p>

         #define COM_INTERFACE_ENTRY(x)\
             { & _ATL_IIDOF(x), \
             offsetofclass(x, _ComMapClass), \
             _ATL_SIMPLEMAPENTRY},

�Q?�Q�聚�?br /> ATL使用_Delegate函数来支持聚合，此时dw存储的是内部对象指针成员变量在外部对象中的偏�U�量�Q�_Delegate利用此偏�U�量获得内部对象指针�Q�然后将查询调用委托�l�它�?/p>

    static HRESULT WINAPI _Delegate( void * pv, REFIID iid, void ** ppvObject, DWORD_PTR dw)
    {
        HRESULT hRes = E_NOINTERFACE;
        IUnknown * p = * (IUnknown ** )((DWORD_PTR)pv + dw);
         if (p != NULL)
            hRes = p -> QueryInterface(iid, ppvObject);
         return hRes;
    }

接口映射表项宏�ؓ�Q?br />

      #define COM_INTERFACE_ENTRY_AGGREGATE(iid, punk)\
          {&iid,\
          (DWORD_PTR)offsetof(_ComMapClass, punk),\
          _Delegate},

�Q?�Q�tear-off
ATL使用_Creator函数来支持tear-off�Q�此时dw中存储的是一个静态_ATL_CREATORDATA�l�构的地址�Q�_Creator利用其中的指向创建函数的指针创徏一个tear-off对象�?br />

         static HRESULT WINAPI _Creator(void* pv, REFIID iid, void** ppvObject, DWORD_PTR dw)
         {
              _ATL_CREATORDATA* pcd = (_ATL_CREATORDATA*)dw;
              return pcd->pFunc(pv, iid, ppvObject);
         }

接口映射表项宏�ؓ�Q?br />

      #define COM_INTERFACE_ENTRY_TEAR_OFF(iid, x)\
          {&iid,\
          (DWORD_PTR)&ATL::_CComCreatorData<\
              ATL::CComInternalCreator< ATL::CComTearOffObject< x > >\
              >::data,\
          _Creator},

_ComCreatorData的相兛_��义如下：

struct _ATL_CREATORDATA
{
_ATL_CREATORFUNC* pFunc;
};

template <class Creator>
class _CComCreatorData
{
public:
static _ATL_CREATORDATA data;
};

template <class Creator>
_ATL_CREATORDATA _CComCreatorData<Creator>::data = {Creator::CreateInstance};

我们�q�可以定义自��q��接口查询辅助函数和辅助数据，通过dw和pFunc来完成各�U�千奇百怪的接口实现方式�Q�需要的只是惌��力�?img src ="http://m.shnenglu.com/HeavenOnProg/aggbug/23233.html" width = "1" height = "1" />

michael 2007-04-30 11:37 发表评论

ATL对对象创建的支持

michael — Tue, 10 Apr 2007 09:36:00 GMT

在COM中对象要通过class factory的接口（通常是IClassFactory�Q�来创徏。在ATL中，class factory也是从CComObjectRootEx�z��的COM�c�，它跟普通的COM�c�M��P��也通过CComObject或其同伴�c�d��逻辑功能跟生存期��理分离�?br /> 在ATL中，class factory�c�d��普通类对象的创建都可以通过被称为“创��”的模板�c�L��创徏�?br />

template <class T1>
class CComCreator
{
public:
    static HRESULT WINAPI CreateInstance(void* pv, REFIID riid, LPVOID* ppv)
    {
        HRESULT hRes = E_OUTOFMEMORY;
        T1* p = NULL;
        p = new T1(pv);
        if (p != NULL)
        {
            p->SetVoid(pv);
            p->InternalFinalConstructAddRef();
            hRes = p->FinalConstruct();
            p->InternalFinalConstructRelease();
            if (hRes == S_OK)
                hRes = p->QueryInterface(riid, ppv);
            if (hRes != S_OK)
                delete p;
        }
        return hRes;
    }
};

“创��”通过提供一个静态函数CreateInstance来创建指定类的实例，�q�且查询指定的接口。第一个参数在实例化普通对象和class factory对象时会有不同：对于普通对象，通常会传递聚合外部对象的IUnknown指针�Q�如果是非聚合创建，可以传递NULL�Q�详见ATL对COM实体�w�䆾的支持四�Q�；�E�后会介�l�在class factory创徏时第一个参数的用处�?br /> 在ATL中，一个class factory对象只能创徏一�U�类型的COM�c�d��例。在class factory的CreateInstance函数中，它不是硬�~�码被创建的对象�c�d��Q�而是通过一�?em>函数指针成员变量来创建它所��理的对象，而这个函数指针指向的通常��是某个COM�cȝ��“创��”类的CreateInstance静态函数的地址�Q�此地址是在class factory对象被它自��n的“创��”的CreateInstance函数创徏旉��过�W�一个参��C��q�来的，class factory重新定义了SetVoid函数�Q��ƈ且保存这个地址�Q?br />

class CComClassFactory :
    public IClassFactory,
    public CComObjectRootEx<CComGlobalsThreadModel>
{
public:
    // IClassFactory
    STDMETHOD(CreateInstance)(LPUNKNOWN pUnkOuter, REFIID riid, void** ppvObj)
    {
        HRESULT hRes = E_POINTER;
        if (ppvObj != NULL)
        {
            *ppvObj = NULL;
            if ((pUnkOuter != NULL) && !InlineIsEqualUnknown(riid))
            {
                hRes = CLASS_E_NOAGGREGATION;
            }
            else
                hRes = m_pfnCreateInstance(pUnkOuter, riid, ppvObj);
        }
        return hRes;
    }

    STDMETHOD(LockServer)(BOOL fLock)
    {
        if (fLock)
            _pAtlModule->Lock();
        else
            _pAtlModule->Unlock();
        return S_OK;
    }

    void SetVoid(void* pv)
    {
        m_pfnCreateInstance = (_ATL_CREATORFUNC*)pv;
    }

    _ATL_CREATORFUNC* m_pfnCreateInstance;
};

         �Ҏ(gu��)��上面的讨论，一个COM�cȝ��创徏者会像这个样子：
         CComCreator< CComObject >
         而一个class factory的创��会像这个样子：
         CComCreator< CComCachedObject >�?br />
         ATL在客戯��求创建CMyClass对象时执行的伪代码如下：

typedef CComCreator< CComCachedObject<CComClassFactory> > CClassFactoryCreator;
typedef CComCreator< CComObject<CMyClass> > CMyClassCreator;

IClassFactory* pcf=NULL;
CClassFactoryCreator::CreateInstance(&CMyClassCreator::CreateInstance,__uuidof(IClassFactory),&pcf);
pcf->CreateInstance(pOuter,__uuidof(IMyInterface),ppvObj);

michael 2007-04-10 17:36 发表评论

ATL对COM实体�w�䆾的支持（四）—�?CComObject及其伙伴

michael — Fri, 06 Apr 2007 07:33:00 GMT

      有了CComObjectRootBase、CComObjectRootEx和线�E�模型特征类�q�些基础原料�Q�CComObject和它的伙伴们便可以自��q��发挥它们的想象了�?br />
1.CComObject —�?普通堆对象
   下面是精��的CComObject模板�cȝ��定义�Q�     �?/p>

template < class Base >
class CComObject : public Base
{
public :
    CComObject( void * = NULL) throw ()
    {
        _pAtlModule -> Lock();
    }

    virtual ~ CComObject() throw ()
    {
        FinalRelease();
        _pAtlModule -> Unlock();
    }

    STDMETHOD_(ULONG, AddRef)() { return InternalAddRef();}
    STDMETHOD_(ULONG, Release)()
    {
        ULONG l = InternalRelease();
         if (l == 0 )
            delete this ;
         return l;
    }

    STDMETHOD(QueryInterface)(REFIID iid, void ** ppvObject) throw ()
    { return _InternalQueryInterface(iid, ppvObject);}

     static HRESULT WINAPI CreateInstance(CComObject < Base >** pp) throw ();
};

“普通堆对象”是使用最为频�J�的�c�，它有如下特征�Q?br />�Q?�Q�在堆中分配内存 —�?计数归零时用delete销�?br />�Q?�Q�支持独立存在的对象 —�?使用InternalXXX来实现IUnknown功能
�Q?�Q��生时锁定服务器，销毁时解锁服务�?—�?适用于大多数COM对象

2. CComAggObject —�?被聚合堆对象

template < class contained >
class CComAggObject :
     public IUnknown,
     public CComObjectRootEx < typename contained::_ThreadModel::ThreadModelNoCS >
{
public :
    CComAggObject( void * pv) : m_contained(pv)
    {
        _pAtlModule -> Lock();
    }
     HRESULT FinalConstruct()
    {
        CComObjectRootEx < contained::_ThreadModel::ThreadModelNoCS > ::FinalConstruct();
         return m_contained.FinalConstruct();
    }
     void FinalRelease()
    {
        CComObjectRootEx < contained::_ThreadModel::ThreadModelNoCS > ::FinalRelease();
        m_contained.FinalRelease();
    }
    virtual ~ CComAggObject()
    {
        FinalRelease();
        _pAtlModule -> Unlock();
    }

    STDMETHOD_(ULONG, AddRef)() { return InternalAddRef();}
    STDMETHOD_(ULONG, Release)()
    {
        ULONG l = InternalRelease();
         if (l == 0 )
            delete this ;
         return l;
    }
    STDMETHOD(QueryInterface)(REFIID iid, void ** ppvObject)
    {
        HRESULT hRes = S_OK;
         if (InlineIsEqualUnknown(iid))
        {
             * ppvObject = ( void * )(IUnknown * ) this ;
            AddRef();
        }
         else
            hRes = m_contained._InternalQueryInterface(iid, ppvObject);
         return hRes;
    }
    static HRESULT WINAPI CreateInstance(LPUNKNOWN pUnkOuter, CComAggObject < contained >** pp)�Q?br />
    CComContainedObject < contained > m_contained;
};

CComAggObject有如下特征：
�Q?�Q�在堆中分配内存
�Q?�Q�支持被聚合聚合的对�?br /> 实现了两份IUnknown�Q�CComAggObject实现了内部聚合类真正的IUnknown�Q�它��理对象的生存期�Q��ƈ且完成接口查询（通过contained对象的_InternalQueryInterface�Q�；contained对象实现了具有�{发功能的IUnknown�Q�它?y��u)��所有的调用转发�l�CComAggObject在构造函��C��收到的外部IUnknown指针�?br />�Q?�Q��生时锁定服务器，销毁时解锁服务�?br />
3. CComTearOffObject —�?tear-off 对象

template < class Base >
class CComTearOffObject : public Base
{
public :
    CComTearOffObject( void * pv)
    {
        m_pOwner = reinterpret_cast < Base::_OwnerClass *> (pv);
        m_pOwner -> AddRef();
    }
     ~ CComTearOffObject()
    {
        FinalRelease();
        m_pOwner -> Release();
    }

    STDMETHOD_(ULONG, AddRef)() throw () { return InternalAddRef();}
    STDMETHOD_(ULONG, Release)() throw ()
    {
        ULONG l = InternalRelease();
         if (l == 0 )
            delete this ;
         return l;
    }
    STDMETHOD(QueryInterface)(REFIID iid, void ** ppvObject) throw ()
    {
         return m_pOwner -> QueryInterface(iid, ppvObject);
    }
};

tear-off对象有如下特征：
�Q?�Q�在堆中分配内存
�Q?�Q�支持在ATL�l��g内部使用的tear-off技�?br />�Q?�Q�生成时锁定父对象，销毁时解锁父对�?br />�Q?�Q�生命周期由自己��理�Q�接口查询委托父对象

4. CComObjectStack —�?栈对�?br />

template <class Base>
class CComObjectStackEx : public Base
{
public:
    CComObjectStackEx(void* = NULL)
    {
        m_hResFinalConstruct = FinalConstruct();
    }
    virtual ~CComObjectStackEx()
    {
        FinalRelease();
    }

    STDMETHOD_(ULONG, AddRef)()
    {
        return 0;
    }

    STDMETHOD_(ULONG, Release)()
    {
        return 0;
    }

    STDMETHOD(QueryInterface)(REFIID iid, void ** ppvObject)
    {
        return _InternalQueryInterface(iid, ppvObject);
    }

    HRESULT m_hResFinalConstruct;
};

栈对象有如下特征�Q?br />�Q?�Q�内存分配于栈上 —�?不需要对象考虑释放问题
�Q?�Q�无引用计数功能
�Q?�Q�构造时初始�?—�?需要在构造函数调用后��查m_hResFinalConstruct�Q�以判断对象是否构造成�?br />�Q?�Q�不锁定服务�?br />
5. CComObjectGlobal —�?全局对象

template <class Base>
class CComObjectGlobal : public Base
{
public:
    CComObjectGlobal(void* = NULL)
    {
        m_hResFinalConstruct = FinalConstruct();
    }
    virtual ~CComObjectGlobal()
    {
             FinalRelease();
    }
    STDMETHOD_(ULONG, AddRef)() throw()
    {
        return _pAtlModule->Lock();
    }
    STDMETHOD_(ULONG, Release)() throw()
    {
        return _pAtlModule->Unlock();
    }
    STDMETHOD(QueryInterface)(REFIID iid, void ** ppvObject) throw()
    {
        return _InternalQueryInterface(iid, ppvObject);
    }
    HRESULT m_hResFinalConstruct;
};

   全局对象有如下特征：
�Q?�Q�在全局数据区分配内�?br />�Q?�Q�初始化时不锁定服务器，引用计数变化时才锁定或者解锁服务器�Q�这使得全局对象可以被用于全局�c�d��对象�Q�以解决服务器和�c�d��之间的死锁问�?br />�Q?�Q�构造方式同栈对�?br />
   �q�有一些其它种�cȝ��生存期管理类�Q�如CComObjectNoLock、CComObjectCached、CComPolyObject�{�等�Q�它们也都有自己独到的用处，我们也可以根据自��q��需要编写自定义的类。��M��CComObjectRootBase、CComObjectRootEx和线�E�模型特征类��像是积木一��P��我们可以��L��的把它们�l�合成想要的形状�?img src ="http://m.shnenglu.com/HeavenOnProg/aggbug/21408.html" width = "1" height = "1" />

michael 2007-04-06 15:33 发表评论

ATL对COM实体�w�䆾的支持（三）—�?讉K��同步支持

michael — Fri, 06 Apr 2007 06:39:00 GMT

1.CComSingleThreadModel和CComMultiThreadModel特征�c�：

class CComSingleThreadModel
{
public:
    static ULONG WINAPI Increment(LPLONG p) throw() {return ++(*p);}
    static ULONG WINAPI Decrement(LPLONG p) throw() {return --(*p);}
    typedef CComFakeCriticalSection AutoCriticalSection;
    typedef CComFakeCriticalSection CriticalSection;
    typedef CComSingleThreadModel ThreadModelNoCS;
};

class CComMultiThreadModel
{
public:
    static ULONG WINAPI Increment(LPLONG p) throw() {return InterlockedIncrement(p);}
    static ULONG WINAPI Decrement(LPLONG p) throw() {return InterlockedDecrement(p);}
    typedef CComAutoCriticalSection AutoCriticalSection;
    typedef CComCriticalSection CriticalSection;
    typedef CComMultiThreadModelNoCS ThreadModelNoCS;
};

其中的CFakeCriticalSection定义如下�Q?br />

class CComFakeCriticalSection
{
public:
    HRESULT Lock() throw() { return S_OK; }
    HRESULT Unlock() throw() { return S_OK; }
    HRESULT Init() throw() { return S_OK; }
    HRESULT Term() throw() { return S_OK; }
};

�q�两个类提供了针对特定套间对象的同步控制支持�?br />CComSingleThreadModel适用于单�U�程套间对象�Q�它不采用�Q何线�E�同步机�Ӟ��CComMultiThreadModel适用于多�U�程套间对象�Q�它使用win32的同步机制来实现�?br />
2.CComObjectRootEx模板�c?br />

template <class ThreadModel>
class CComObjectRootEx : public CComObjectRootBase
{
public:
    typedef ThreadModel _ThreadModel;
    typedef typename _ThreadModel::AutoCriticalSection _CritSec;
    typedef CComObjectLockT<_ThreadModel> ObjectLock;

    ULONG InternalAddRef()
    {
        return _ThreadModel::Increment(&m_dwRef);
    }
    ULONG InternalRelease()
    {
        return _ThreadModel::Decrement(&m_dwRef);
    }

    void Lock() {m_critsec.Lock();}
    void Unlock() {m_critsec.Unlock();}

private:
    _CritSec m_critsec;
};

它��用传入的�U�程模型特征�c�L��实现对象独立存在时所需要的引用计数支持�Q�同时提供了一个方便对象开发��用的同步锁，我们可以使用�q�个锁来完成对自定义数据讉K��的保护�?img src ="http://m.shnenglu.com/HeavenOnProg/aggbug/21403.html" width = "1" height = "1" />

michael 2007-04-06 14:39 发表评论

ATL对COM实体�w�䆾的支持（二）—�?CComObjectRootBase

michael — Fri, 06 Apr 2007 05:51:00 GMT

下面是CComObjectRootBase的关键代码：

class CComObjectRootBase
{
public :
     // 构造支�?br />     //
     HRESULT FinalConstruct();
     void FinalRelease();

     //  接口查询支持
     //
     static HRESULT WINAPI InternalQueryInterface(void* pThis,
        const _ATL_INTMAP_ENTRY* pEntries, REFIID iid, void** ppvObject);

    static HRESULT WINAPI _Break(void*, REFIID iid, void**  , DWORD_PTR );
    static HRESULT WINAPI _NoInterface(void*  , REFIID , void**  , DWORD_PTR );
    static HRESULT WINAPI _Creator(void* pv, REFIID iid, void**ppvObject, DWORD_PTR dw);
    static HRESULT WINAPI _Delegate(void* pv, REFIID iid, void** ppvObject, DWORD_PTR dw);
    static HRESULT WINAPI _Chain(void* pv, REFIID iid, void** ppvObject, DWORD_PTR dw);
    static HRESULT WINAPI _ChainAttr(void* pv, REFIID iid, void** ppvObject, DWORD_PTR dw);
    static HRESULT WINAPI _Cache(void* pv, REFIID iid, void** ppvObject, DWORD_PTR dw);

    // 聚合支持
    //
    ULONG OuterAddRef()
    {
        return m_pOuterUnknown->AddRef();
    }
    ULONG OuterRelease()
    {
        return m_pOuterUnknown->Release();
    }
    HRESULT OuterQueryInterface(REFIID iid, void ** ppvObject)
    {
        return m_pOuterUnknown->QueryInterface(iid, ppvObject);
    }

    // 实体�w�䆾支持
    //
    union
    {
        long m_dwRef;
         IUnknown* m_pOuterUnknown;
    };
};

CComObjectRootBase主要功能分�ؓ�Q?br />�Q?�Q�构造支持：
即FinalConstruct和FinalRelease�Q�它们用于安全的构造和销毁对象�?br />�Q?�Q�接口查询支�?br /> 通过接口映射表来完成接口查询功能�Q�详�l�内容见后面的文章�?br />�Q?�Q�聚合状态下引用计数操作的支�?br /> 提供了将IUnknown��h��委托�l�外部组件的支持。当对象独立存在�Ӟ��对引用计数操作的支持被放�|�于CComObjectRootEx中，因�ؓ涉及��C��套间和访问同步�?br />�Q?�Q�实体��n份支�?br /> 使得对象可以独立存在或者被聚合�Q�因��行时��d��象只能以一�U�方式存在，所以��用了union�?img src ="http://m.shnenglu.com/HeavenOnProg/aggbug/21393.html" width = "1" height = "1" />

michael 2007-04-06 13:51 发表评论

michael — Fri, 06 Apr 2007 03:46:00 GMT

一个COM对象必须实现IUnknown接口所规定的功能，即生命期��理和运行时�c�d��转换�?br />�Q?�Q�基本IUnknow功能
对象的生存方式可以是堆存储、栈存储以及全局存储�Q�同时COM�q�提供了一�U�被聚合的生存方式。生存方式不同，AddRef、Release和QueryInterface的实现方式就不同。比如：对于堆方式，Release要在引用计数归零时负责释攑֠��I�间�Q�而栈以及全局方式则不必；对于聚合方式�Q�AddRef、Release以及大部分的QueryInterface调用要委托给外部对象�?br /> ��Z��辑ֈ�对象的逻辑功能与其生存方式的分��，COM把对IUnknown基本功能的实现推�q�到�c�d��ơ结构的最底层�Q�即CComObject�Q�或它的其他伙伴�Q�处�?br /> CComObjectRootBase为CComObject的实现提供原材料的支持，如提供引用计数变量、基本的接口查询机制�{�，它是一个“功能集中类”�?br />�Q?�Q�套间安全支�?br /> �Ҏ(gu��)��对象所处的套间�c�d��Q�对象功能的实现需要不同的同步支持。对于单�U�程套间对象�Q�由COM库来保证讉K��的同步；而对于多�U�程套间对象�Q�需要自己来同步调用。�ؓ了��套间安全支持与逻辑功能分离�Q�ATL提供了一�l�提供线�E�安全操作支持的特征�c�（traits�c�）—�?CComSingleThreadModel及其伙伴。它们提供了对一个LONG变量“恰好线�E�安全”的增减操作�Q�以及跟套间�c�d��匚w��的CriticalSection功能�c�R�?br /> ATL同时提供了CComObjectRootEx模板�c�，它以某种ThreadModel特征�c�M��为参敎ͼ�提供对引用计数“恰好线�E�安全”的操作�Q��ƈ且提供了一个用于对象同步的锁�?br /> PS:“恰好线�E�安全”的操作的意思是�Q�对于需要线�E�同步的对象�Q�提供win32 CriticalSection支持�Q�对于不需要的对象�Q�则什么也不做�?br />

michael 2007-04-06 11:46 发表评论