ATL Internals 2ed复习.chapter 4.IUnknown

最新推荐文章于 2017-07-18 14:43:45 发布
最新推荐文章于 2017-07-18 14:43:45 发布
阅读量699 收藏
点赞数
分类专栏： COM/ATL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mcmcmc/article/details/8043721
版权

Standalone Reference Counting

template <class ThreadModel> class CComObjectRootEx : public CComObjectRootBase

中的类型定义：

typedef ThreadModel _ThreadModel;

typedef typename _ThreadModel::AutoCriticalSection _CritSec;

typedef typename _ThreadModel::AutoDeleteCriticalSection _AutoDelCritSec;

typedef CComObjectLockT<_ThreadModel> ObjectLock;

数据部分：

_AutoDelCritSec m_critsec;（在CComObjectRootEx<CComSingleThreadModel>该部分未使用）

其中：

template <class ThreadModel>                                    
class CcomObjectLockT {                                         
public:                                                         
    CComObjectLockT(CComObjectRootEx<ThreadModel>* p) {         
        if (p)                                                  
            p->Lock();                                          
        m_p = p;                                                
    }                                                           
                                                                
    ~CComObjectLockT() {                                        
        if (m_p)                                                
            m_p->Unlock();                                      
    }                                                           
    CComObjectRootEx<ThreadModel>* m_p;                         
};                                                              
                                                                
template <>                                                     
class CComObjectLockT<CComSingleThreadModel> {                  
public:                                                         
    CComObjectLockT(CComObjectRootEx<CComSingleThreadModel>*) {}
    ~CComObjectLockT() {}                                       
};


 

InternalAddRef()调用_ThreadModel::Increment(&m_dwRef)

InternalRelease()调用return _ThreadModel::Decrement(&m_dwRef)

CComObjectRootBase

class CComObjectRootBase {                                      
public:                                                         
    CComObjectRootBase() { m_dwRef = 0L; }                      
    ...                                                         
    ULONG OuterAddRef() {                                       
        return m_pOuterUnknown->AddRef();                       
    }                                                           
    ULONG OuterRelease() {                                      
        return m_pOuterUnknown->Release();                      
    }                                                           
    HRESULT OuterQueryInterface(REFIID iid, void ** ppvObject) {
        return m_pOuterUnknown->QueryInterface(iid, ppvObject); 
    }                                                           
    ...                                                         
    union {                                                     
        long      m_dwRef;		//stand alone                                      
        IUnknown* m_pOuterUnknown;  //Aggregate                           
    };                                                          
};

FinalConstruct和FinalRelease

由于COM创建对象的复杂性，该类还提供了空的函数，派生类可以override：

HRESULT FinalConstruct();

void FinalRelease();

CComObject::~CComObject() { 
    m_dwRef = -(LONG_MAX/2);
    FinalRelease();         
    _AtlModule->Unlock();   
}



在创建对象时，有时会发生提前Release现象，所以需要提前AddRef，如：

STDMETHODIMP
CPenguinCO::CreateInstance(IUnknown* pUnkOuter, REFIID riid,
    void** ppv) {
    *ppv = 0;
    if( !pUnkOuter ) {
        CComObject<CPenguin>* pobj = new CComObject<CPenguin>;
        if( FAILED(hr) ) return E_OUTOFMEMORY;

        // Protect object from pre-mature destruction (maybe)
        pobj->InternalFinalConstructAddRef();
        hr = pobj->FinalConstruct();
        pobj->InternalFinalConstructRelease();

        if( SUCCEEDED(hr) ) ...
        return hr;
    }
    ...
}


DECLARE_PROTECT_FINAL_CONSTRUCT宏

CComObjectRootBase已经定义了2个空函数：

class CComObjectRootBase {              
public:                                 
  ...                                   
  void InternalFinalConstructAddRef() {}
  void InternalFinalConstructRelease() {
    ATLASSERT(m_dwRef == 0);            
  }                                     
  ...                                   
};


ATL则定义了宏加以扩展：

#define DECLARE_PROTECT_FINAL_CONSTRUCT() \                  
  void InternalFinalConstructAddRef() { InternalAddRef(); } \
  void InternalFinalConstructRelease() { InternalRelease(); }


用户可以这样使用：

class CPenguin : ... {
public:
  HRESULT FinalConstruct();
  DECLARE_PROTECT_FINAL_CONSTRUCT()
  ...
};


注意：为了安全，每一个重新定义FinalConstruct的类都应该加这个宏

ATL_NO_VTABLE

如果使用了这个宏，在构造函数中禁止使用虚函数；的确要使用，应该放到FinalConstruct()中

Table-Driven QueryInterface

static HRESULT WINAPI                      
CComObjectRootBase::InternalQueryInterface(
    void*                    pThis,        //object's this，注意该函数为static
    const _ATL_INTMAP_ENTRY* pEntries,     //表头
    REFIID                   iid,          
    void**                   ppvObject);   //[out]vptr


pEntry使用一个表结构，每一个entry都对应一个interface：

struct _ATL_INTMAP_ENTRY {     
    const IID*           piid; 
    DWORD                dw;   	//编译时确定的interface和pThis的offset
    _ATL_CREATORARGFUNC* pFunc;	//_ATL_SIMPLEMAPENTRY等等
};

该结构还提供一个GetUnknown()，可以得到object的IUnknown*，可以消除多重继承的二义性，例如：

HRESULT FlyInAnAirplane(IUnknown* punkPassenger);

// Penguin.cpp
STDMETHODIMP CPenguin::Fly() {
    return FlyInAnAirplane(this); // ambiguous
}

 

STDMETHODIMP CPenguin::Fly() {
    return FlyInAnAirplane(this->GetUnknown()); // unambiguous
}


Your Class

支持IDispatch：IDispatchImpl<IPenguin, &IID_IPenguin>

支持多重继承：COM_INTERFACE_ENTRY2(itf, branch)，

但是注意下面代码，在custom环境下没有问题，但是在script环境下编程语言不支持QueryInterface，所以ISnappyDresser并不能被访问到：

class CPenguin :
    public CComObjectRootEx<CComSingleThreadModel>,
    public IDispatchImpl<IBird, &IID_IBird>,
    public IDispatchImpl<ISnappyDresser, &IID_ISnappyDresser> {
public:
BEGIN_COM_MAP(CPenguin)
    COM_INTERFACE_ENTRY(IBird)
    COM_INTERFACE_ENTRY(ISnappyDresser)
    COM_INTERFACE_ENTRY2(IDispatch, IBird) // Compiles
                                           // (unfortunately)
END_COM_MAP()
...
};

// Since IBird is the default, its operations are available
penguin.fly
// Since ISnappyDresser is not the default, its operations
// aren't available
penguin.straightenTie // runtime error


CComObject Et Al

由于CComObjectRootEx并未定义IUnknown的3个方法，所以下面的代码是会导致编译错误的：

STDMETHODIMP
CPenguinCO::CreateInstance(IUnknown* pUnkOuter,
    REFIID riid, void** ppv) {
    ...
    CPenguin* pobj = new CPenguin; // IUnknown not implemented
    ...
}


Standalone Activation

ATL定义了CComObject用于standalone

 

template <class Base>                                            
class CComObject : public Base {                                 
public:                                                          
    typedef Base _BaseClass;                                     
    CComObject(void* = NULL)                                     
    { _pAtlModule->Lock(); }    // Keeps server loaded           
                                                                 
    // Set refcount to -(LONG_MAX/2) to protect destruction and  
    // also catch mismatched Release in debug builds             
    ~CComObject() {                                              
        m_dwRef = -(LONG_MAX/2);                                 
        FinalRelease();                                          
#ifdef _ATL_DEBUG_INTERFACES                                     
        _AtlDebugInterfacesModule.DeleteNonAddRefThunk(          
            _GetRawUnknown());                                   
#endif                                                           
        _pAtlModule->Unlock();   // Allows server to unload      
    }                                                            
    STDMETHOD_(ULONG, AddRef)() {return InternalAddRef();}       
    STDMETHOD_(ULONG, Release)() {                               
        ULONG l = InternalRelease();                             
        if (l == 0) delete this;                                 
        return l;                                                
    }                                                            
                                                                 
    STDMETHOD(QueryInterface)(REFIID iid, void ** ppvObject)     
    {return _InternalQueryInterface(iid, ppvObject);}            
                                                                 
    template <class Q>                                           
    HRESULT STDMETHODCALLTYPE QueryInterface(Q** pp)             
    { return QueryInterface(__uuidof(Q), (void**)pp); }          
                                                                 
    static HRESULT WINAPI CreateInstance(CComObject<Base>** pp) ;
};


例子：

STDMETHODIMP
CPenguinCO::CreateInstance(IUnknown* pUnkOuter, REFIID riid,
    void** ppv) {
    *ppv = 0;
    if( pUnkOuter ) return CLASS_E_NOAGGREGATION;
    // Read on for why not to use new like this!
    CComObject<CPenguin>* pobj = new CComObject<CPenguin>;	//注意这也是不对的，后面将会讲到为什么不使用new
    if( pobj ) {
        pobj->AddRef();
        HRESULT hr = pobj->QueryInterface(riid, ppv);
        pobj->Release();
        return hr;
    }
    return E_OUTOFMEMORY;
}

Aggregated Activation

template <class contained>                                    
class CComAggObject :                                         
    public IUnknown,                                          
    public CComObjectRootEx<                                  
        contained::_ThreadModel::ThreadModelNoCS> {           
public:                                                       
    typedef contained _BaseClass;                             
    CComAggObject(void* pv) : m_contained(pv)                 
    { _pAtlModule->Lock(); }                                  
                                                              
    ~CComAggObject() {                                        
        m_dwRef = -(LONG_MAX/2);                              
        FinalRelease();                                       
        _pAtlModule->Unlock();                                
    }                                                         
                                                              
    STDMETHOD(QueryInterface)(REFIID iid, void ** ppvObject) {
        ATLASSERT(ppvObject != NULL);                         
        if (ppvObject == NULL)                                
            return E_POINTER;                                 
        *ppvObject = NULL;                                    
                                                              
        HRESULT hRes = S_OK;                                  
        if (InlineIsEqualUnknown(iid)) {                      
            *ppvObject = (void*)(IUnknown*)this;              
            AddRef();                                         
        }                                                     
        else                                                  
            hRes = m_contained._InternalQueryInterface(iid,   
                ppvObject);                                   
        return hRes;                                          
    }                                                         
                                                              
    STDMETHOD_(ULONG, AddRef)()                               
    { return InternalAddRef(); }                              
                                                              
    STDMETHOD_(ULONG, Release)() {                            
        ULONG l = InternalRelease();                          
        if (l == 0) delete this;                              
        return l;                                             
    }                                                         
                                                              
    template <class Q>                                        
    HRESULT STDMETHODCALLTYPE QueryInterface(Q** pp)          
    { return QueryInterface(__uuidof(Q), (void**)pp); }       
    static HRESULT WINAPI CreateInstance(LPUNKNOWN pUnkOuter, 
        CComAggObject<contained>** pp);                       
                                                              
    CComContainedObject<contained> m_contained;               
};                                                            

template <class Base>                                         
class CComContainedObject : public Base {                     
public:                                                       
    typedef Base _BaseClass;                                  
    CComContainedObject(void* pv) {                           
        m_pOuterUnknown = (IUnknown*)pv;                      
    }                                                         
                                                              
    STDMETHOD(QueryInterface)(REFIID iid, void ** ppvObject) {
      return OuterQueryInterface(iid, ppvObject);             
    }                                                         
                                                              
    STDMETHOD_(ULONG, AddRef)()                               
    { return OuterAddRef(); }                                 
                                                              
    STDMETHOD_(ULONG, Release)()                              
    { return OuterRelease(); }                                
                                                              
    template <class Q>                                        
    HRESULT STDMETHODCALLTYPE QueryInterface(Q** pp)          
    { return QueryInterface(__uuidof(Q), (void**)pp); }       
                                                              
    IUnknown* GetControllingUnknown()                         
    { return m_pOuterUnknown; }                               
};


 

例子：

CComAggObject<CPenguin>* pobj = new CComAggObject<CPenguin>(pUnkOuter);

CComPolyObject

class CComPolyObject :                                          
    public IUnknown,                                            
    public CComObjectRootEx<                                    
        contained::_ThreadModel::ThreadModelNoCS> {             
public:                                                         
    ...                                                         
    CComPolyObject(void* pv) : m_contained(pv ? pv : this) {...}
    ...                                                         
};

用于选择性判断是否内聚，例子：

 

STDMETHODIMP
CPenguinCO::CreateInstance(IUnknown* pUnkOuter, REFIID riid,
    void** ppv) {
    *ppv = 0;
    CComPolyObject<CPenguin>* pobj =
        new CComPolyObject<CPenguin>(pUnkOuter);
    ...
}


CComObjectCached

template <class Base>                 
class CComObjectCached : public Base {
public:                               
    ...                               
    STDMETHOD_(ULONG, AddRef)() {     
        ULONG l = InternalAddRef();   
        if (l == 2)                   
            _pAtlModule->Lock();      
        return l;                     
    }                                 
    STDMETHOD_(ULONG, Release)() {    
        ULONG l = InternalRelease();  
        if (l == 0)                   
            delete this;              
        else if (l == 1)              
            _pAtlModule->Unlock();    
        return l;                     
    }                                 
    ...                               
};


一旦建立，该对象能够在server中一直存在下去，例子：

static CComObjectCached<CPenguinCO>* g_pPenguinCO = 0;

BOOL WINAPI DllMain(HINSTANCE, DWORD dwReason, void*) {
  switch( dwReason ) {
  case DLL_PROCESS_ATTACH:
      g_pPenguinCO = new CComObjectCached<CPenguinCO>();

      // 1st ref. doesn't keep server alive
      if( g_pPenguinCO ) g_pPenguinCO->AddRef();
  break;

  case DLL_PROCESS_DETACH:
      if( g_pPenguinCO ) g_pPenguinCO->Release();
  break;
  }
  return TRUE;
}

STDAPI DllGetClassObject(REFCLSID clsid, REFIID riid,
    void** ppv) {
    // Subsequent references do keep server alive
    if( clsid == CLSID_Penguin && g_pPenguinCO )
      return g_pPenguinCO->QueryInterface(riid, ppv);
    return CLASS_E_CLASSNOTAVAILABLE;
}


CComObjectNoLock

template <class Base>                 
class CComObjectNoLock : public Base {
public:                               
    ...                               
    STDMETHOD_(ULONG, AddRef)()       
    { return InternalAddRef(); }      
                                      
    STDMETHOD_(ULONG, Release)() {    
        ULONG l = InternalRelease();  
        if (l == 0) delete this;      
        return l;                     
    }                                 
  ...                                 
};


有时，server的生命并不受到object的消亡的影响，例如在out-process中，例子：

int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) {
    CoInitialize(0);

    CComObjectNoLock<CPenguinCO>* pPenguinCO =
        new CComObjectNoLock<CPenguinCO>();
    if( !pPenguinCO ) return E_OUTOFMEMORY;
        pPenguinCO->AddRef();

    DWORD   dwReg;
    HRESULT hr;

    // Reference(s) cached by ole32.dll won't keep server
    // from shutting down
    hr = CoRegisterClassObject(CLSID_Penguin, pPenguinCO, ...,
        &dwReg);
    if( SUCCEEDED(hr) ) {
        MSG msg; while( GetMessage(&msg, 0, 0, 0) ) DispatchMessage(&msg);
        CoRevokeClassObject(dwReg);
        pPenguinCO->Release();
    }

    CoUninitialize();
    return hr;
}


CComObjectGlobal

template <class Base>                                           
class CComObjectGlobal : public Base {                          
public:                                                         
  ...                                                           
  STDMETHOD_(ULONG, AddRef )() { return _pAtlModule->Lock(); }   
  STDMETHOD_(ULONG, Release)() { return _pAtlModule->Unlock(); }
  ...                                                           
};


这类对象和server的寿命相同，例如：

// No references yet, so server not forced to stay alive
static CComObjectGlobal<CPenguinCO> g_penguinCO;

STDAPI DllGetClassObject(REFCLSID clsid, REFIID riid,
    void** ppv) {
    // All references keep the server alive
    if( clsid == CLSID_Penguin )
        return g_penguinCO.QueryInterface(riid, ppv);
    return CLASS_E_CLASSNOTAVAILABLE;
}

CComObjectStack

不要在这个对象上调用IUnknown的函数，例子：

void DoABadThing(IBird** ppbird) {
    CComObjectStack<CPenguin> penguin;
    penguin.Fly();           // Using IBird method is OK
    penguin.StraightenTie(); // Using ISnappyDresser method
                             // also OK

    // This will trigger an assert at runtime
    penguin.QueryInterface(IID_IBird, (void**)ppbird);
}


CComObjectStackEx

可以在对象的栈有效范围内调用IUnknown函数，例子：

void PlayWithBird() {
    CComObjectStackEx<CPenguin> penguin;
    IBird* pBird = NULL;
    penguin.QueryInterface(IID_IBird,
        (void**)&pBird);          // OK -> no assert
    DoBirdTrickes(pBird);
}

void DoBirdTricks(IBird* pBird) {
    pBird->Fly();                 // IBird methods OK
    ISnappyDresser* pPenguin = NULL;
    pBird->QueryInterface(IID_ISnappyDresser,
        (void**)&pPenguin);       // OK
    pPenguin->StraightenTie();    // ISnappyDresser methods OK
    pPenguin->Release();          // OK -> no assert
}


总结：

Class

Standalone or Aggregated

Heap or Stack

Existence Keeps Server Alive

Extent Refs Keep Server Alive

Useful IUnkown Methods

CcomObject

Standalone

Heap

Yes

Yes

Yes

CComAggObject

Aggregated

Heap

Yes

Yes

Yes

CComPolyObject

Standalone or aggregated

Heap

Yes

Yes

Yes

CComObjectCached

Standalone

Heap

No

Second Reference

Yes

CComObjectNoLock

Standalone

Heap

No

No

Yes

CComObjectGlobal

Standalone

Data seg.

No

Yes

Yes

CComObjectStack

Standalone

Stack

No

No

No

CComObjectStackEx

Standalone

Stack

No

No

Yes

 


 

I_ask_who
关注
专栏目录
ATL Internals 2ed复习.chapter 4.Creators
mcmcmc的专栏
10-06 513
由于CreateInstance过程中需要调用FinalConstruct，用户很容易忘记，所以ATL提供了Creator类，这些类提供了一个静态函数 static HRESULT WINAPI CreateInstance(void* pv, REFIID riid, LPVOID* ppv); CComCreator template
ATL Internals 2ed复习.chapter 3.CComSafeArray
mcmcmc的专栏
10-01 687
template VARTYPE _vartype = _ATL_AutomationType::type> class CComSafeArray { ... public:
深入解析ATL(第2版) ATL internals 2nd Edition Working with ATL8
08-11
清晰pdf ,这是第二部分。 ATL的发明人Jim Springfield亲自作序推荐 四位顶尖的Windows编程专家倾力合作，绝对经典再现 COM、ATL开发人员的必备宝典 深入分析ATL实现COM内幕细节，展示COM应用中的各类漂亮技巧 本书主要介绍了ATL技术的原理、内部实现和应用技巧，由当今4 位顶尖的 Windows技术专家联合撰写。全书内容丰富，深入浅出，主要涵盖了ATL内部架构和实现方法、运用向导简化ATL开发、C++/COM/ATL中字符串的使用技巧、理解并正确实现IUnknown、
ATL Internals 2ed复习.chapter 6.Table driven QueryInterface
mcmcmc的专栏
10-07 535
The Raw Interface Map ATL实现QueryInterface的方法是调用CComObjectRootBase::InternalQueryInterface()： static HRESULT WINAPI CComObjectRootBase::InternalQueryInterf
勿在浮沙筑高台
跟随我的心
03-19 1352
最早读到这句话是在侯捷先生于早期的《程序员》杂志上发表的文章；《深入浅出MFC》让我第一次领略了此话的精髓；《ATL Internal》为我设计公司的组件平台夯实了基础。这些经历虽已过去了好几年，自己也逐渐脱离了技术第一线，但这种Inside、Internal的深入体验，依然会时常牵动我的心，总有旧梦重温的愿望。It is time for Spring!
ATL Internals 2ed复习.chapter 3.CComVariant
mcmcmc的专栏
10-01 600
在使用COM时，有时候用户不知道函数的输入参数，输出参数的具体类型。例如用户传入long类型，函数会把用户传入的long转换成自己想要的参数类型例如BSTR。其中起到关键作用的就是VARIANT类型 VARIANT.vt==当前存储的数据类型 VARIANT.(bVal,iVal,...,pvarVal,byref)==当前存储的数据   正确使用VARIANT需要注意： 需要使用Var
ATL Internals 2ed复习.chapter 3.SAFEARRAY
mcmcmc的专栏
10-01 519
A Review of the COM SAFEARRAY Data Type 为了在COM函数间传递Array参数，IDL定义了SAFEARRAY类型： interface IMyInterface : IUnknown { HRESULT GetArray([out,retval] SAFEARRAY(VARIANT_BOOL)*
ATL Internals 2ed复习.chapter 3.CComPtr CComQIPtr
mcmcmc的专栏
10-01 827
A Review of Smart Pointers 使用smart pointers的好处： 对象析构时，自动release interface 发生异常时，创建在栈上的对象自动release interface assignment操作时，旧的interface自动release，新的interface自动AddRef 提供不同的构造函数 可以在大部分用raw pointer的地方
ATL 教程 (2).pdf
11-11
2. 从“添加类”对话框中，选择“ATL”文件夹，然后选择“ATL 控件”模板。 3. 输入简称为“PolyCtl”，其他字段会自动填充。 4. 在“ATL 控件向导”中，配置控件的名称、类名、文件名等，并启用多格式错误信息和...
atl1c_main.rar_com.qualcom
09-23
4. **ATL1C芯片**：ATL1C是Qualcomm Atheros生产的一种千兆以太网控制器，它支持PCI Express接口，能够提供100Mbps和1000Mbps的高速网络连接。驱动程序就是为了让操作系统能够与这个硬件通信。 5. **源代码**：提供...
ATL 教程 (2).docx
最新发布
11-11
在本文档中，我们将深入探讨ATL教程，特别是如何在Visual Studio .NET 2003环境下创建一个简单的ActiveX控件，该控件能够绘制圆形和实心多边形，并响应用户的交互。 首先，创建ATL项目是整个过程的第一步。在Visual...
ATL开发技巧之一.zip_ATL
09-23
4. `VoxChs.cpp`, `VoxSys.cpp`, `VoxCh.cpp`：这些文件可能是特定功能模块的实现，比如语音处理相关的代码。在ATL项目中，每个`.cpp`文件通常对应一个或多个COM接口的实现。 5. `StdAfx.cpp`：这是一个预编译...
ATL Internals 2ed复习.chapter 5.Object Map
mcmcmc的专栏
10-07 734
由于有3种COM Server，ATL提供了CAtlModule的派生类对应 CAtlDllModuleT：in-process dll CAtlExeModuleT：out-process exe CAtlServiceModuleT：system service exe   CAtlModule使用了Object Map管理server中所有的类 CAtlModule的职责 找到
一大堆人对IUnknown的错误用法
哈哈 哈 哈哈，哈 哈 哈哈哈
07-18 1572
背景略过...，检查代码，发现公司项目里某代码片段（为节省篇幅，片段经过重写，并以省略号代替部分次要函数的实现）如下： template&lt; class _Bty &gt; class CUnknownImpl : public _Bty { public: STDMETHOD( QueryInterface )( _In_ REFIID iid, _Deref_out_ voi...
深入理解ATL：《ATL Internals》书评
本文是一篇对《ATL Internals》这本书的书评，作者潘爱民，发表于2000年5月7日。文章讨论了ATL（Active Template Library）这一关键的Windows开发技术，并对比了它与MFC（Microsoft Foundation Classes）的区别。ATL...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值