加载中…
个人资料
南冠彤
南冠彤
  • 博客等级:
  • 博客积分:0
  • 博客访问:413,133
  • 关注人气:59
  • 获赠金笔:0支
  • 赠出金笔:0支
  • 荣誉徽章:
相关博文
推荐博文
谁看过这篇博文
加载中…
正文 字体大小:

[转载]2011年12月02日

(2013-06-28 10:34:22)
标签:

转载

分类: DirectShow
原文地址:2011年12月02日作者:woodstone121

解释CComPtr和CComQIPtr  

2008-12-11 17:19:21 分类: VC  标签: |字号 订阅

对于操作原始的接口指针是比较麻烦的,需要我们自己控制引用记数、API 调用、异常处理。于是 ATL 提供了2个智能指针的模板包装类,CComPtr<> 和 CComQIPtr<>,这两个类都在 <atlbase.h> 中声明。CComQIPtr<> 包含了 CComPtr<>的所有功能,因此我们可以完全用 CComQIPtr<> 来使用智能接口指针,唯一要说明的一点就是:CComQIPtr<> 由于使用了运算符的重载功能,它会自动帮我们调用QueryInterface()函数,因此 CComQIPtr<> 唯一的缺点就是不能定义 IUnknown * 指针。

      // 智能指针 smart pointer,按照匈牙利命名法,一般以 sp 开头来表示变量类型
     CComPtr < IUnknown > spUnk; // 正确
     // 假设 IFun 是一个接口类型
     CComPtr < IFun > spFun; // 正确
     CComQIPtr < IFun > spFun; // 正确
     CComQIPtr < IFun, &IID_IFun > spFun; // 正确
     CComQIPtr < IUnknown > spUnk; // 错误!CComQIPtr不能定义IUnknown指针
  
给智能指针赋值的方法:
     CComQIPtr < IFun > spFun; // 调用构造函数,还没有赋值,被包装的内部接口指针为 NULL
    
     CComQIPtr < IFun > spFun( pOtherInterface ); // 调用构造函数,内部接口指针赋值为
     // 通过 pOtherInterface 这个普通接口指针调用QueryInterface()得到的IFun接口指针
    
     CComQIPtr < IFun > spFun( spOtherInterface ); // 调用构造函数,内部接口指针赋值为
     // 通过 spOtherInterface 这个只能接口指针调用QueryInterface()得到的IFun接口指针
    
     CComQIPtr < IFun > spFun ( pUnknown ); // 调用构造函数,由IUnknown的QueryInterface()得到IFun接口指针
    
     CComQIPtr < IFun > spFun = pOtherInterface; // = 运算符重载,含义和上面一样
     spFun = spOtherInterface; // 同上
     spFun = pUnknown; // 同上
    
     pUnknown->QueryInterface( IID_IFun, &sp ); // 也可以通过QueryInterface赋值
    
     // 智能指针赋值后,可以用条件语句判断是否合法有效
     if ( spFun ){}   // 如果指针有效
     if ( NULL != spFun ){} // 如果指针有效
    
     if ( !spFun ){}   // 如果指针无效
     if ( NULL == spFun ){} // 如果指针无效

智能指针调用函数的方法:
     spFun.CoCreateInstance(...); // 等价与 API 函数::CoCreateInstance(...)
     spFun.QueryInterface(...); // 等价与 API 函数::QueryInterface()
    
     spFun->Add(...); // 调用内部接口指针的接口函数

     // 调用内部接口指针的QueryInterface()函数,其实效果和 spFun.QueryInterface(...) 一样
     spFun->QueryInterface(...);
    
     spFun.Release(); // 释放内部的接口指针,同时内部指针赋值为 NULL
     spFun->Release(); // 错!!!一定不要这么使用。
     // 因为这个调用并不把内部指针清空,那么析构的时候会被再次释放(释放了两次)

 

CComPtr 类是一个智能COM接口指针类.我们可以为指定的接口指针类型量体裁衣地创建实例
如:
CComPtr<IUnknown>       punk;
CComPtr<INamedObject>    pno;


CComQIPtr 类是一个更智能的com接口指针类, 能够完成CComPtr的所有功能,以及更多的功能
如:
CComPtr<IUnknown>    punk=;
CCOMQIPtr<INamedObject> pno = punk;

CComDispatchDriver 类是智能的IDispatch接口指针
如:
CComVariant     v;
CCOMDispatchDriver  pdisp = ;

HRESULT hr = pdisp->GetProperty(DISPID_COUNT,&V);// GET THE COUNT PROPERTY


CComPtr构造函数
CComPtr( ) {p==NULL};
CComPtr( T* lp ) {if((p=lp)!=NULL) p->AddRef();};
CComPtr ( const CComPtr< T >& lp )
{
    if((p == lp.p)!=NULL)    p->AddRef();

}

析构函数
~CComPtr() if(p) p-Release();


CCOMQIPtr 构造函数
当初始值与智能指针的类型相同时,这个构造函数与CComPtr 类一样,只是简单的对输入的接口指针调用AddRef.但是,当指定不同的类型来调用下面的构造函数时,构造函数会与输入的接口指针中查询适当的接口
CComQIPtr(IUnKnown* lp)
{
    p=NULL;
    if(lp!=NULL)
    lp->QueryInterface(*piid,(void**)&p);
}
构造函数永远不会失败,然而QueryInferface调用可能会不成功,当不能获得被请求的接口时,
CComQIPtr会把内部的指针置为NULL

void func(IUnknown* punk)
{
    CComQIPtr<INamedObject> pno(punk);
    if(pno)
    {
    ...
    }
}
我们可以通过检查是否为null 指针,从而知道查询是否失败

对象实例化方法
   智能接口指针类提供了一个被称为CoCreateInstance的重载方法,用它可以是实例化一个对象,并且获得对象的一个接口指针.提供2钟形式,第一种要求实例化类的类表识CLSID
第2钟要求实例化类的程序标识符ProgID

HRESULT CoCreateInstance(
   LPCOLESTR szProgID,
   LPUNKNOWN pUnkOuter = NULL,
   DWORD dwClsContext = CLSCTX_ALL
) throw( );


HRESULT CoCreateInstance(
   REFCLSID rclsid,
   LPUNKNOWN pUnkOuter = NULL,
   DWORD dwClsContext = CLSCTX_ALL
) throw( );

如:
ISpeaker* pSpeaker;
HRESULT hr = ::CreateInstance(__uuidof(Demagogue),NULL,CLSCTX,__uuidof(ISpeaker,(void**)&pSpeaker);
pSpeaker->Release();

CComPtr<ISpeaker> pSpeaker;
HRESULT hr = pSpeaker.CoCreateInstance(__uuidof(DEMAGOGUE));


CComPtr和CComQIPtr 的资源管理
我们必须在调用CoUninitialize方法之前释放所有的接口指针.这意味着如果申请的局部或全局变量,我们不能等到CComPtr的析构函数来释放指针.全局和静态变量的析构函数在主函数推出之后才执行。此时CoUninitialize早已完成
  我们可以把智能指针赋值为NULL来释放内部的接口指针。也可以更明确的调用Release方法

 

COM接口指针很危险,因为使用过程中需要每一个使用者都要严格并且正确的AddRef和Release,一旦出现问题,就会造成对象不能被正常释放,或者对象被重复删除,造成程序崩溃。所以使用COM接口,必须小心翼翼才行。
但是,即使所有的代码中,都正确的AddRef和Release,也不一定能保证万无一失,例如:
void SomeApp( IHello * pHello )
{
IHello* pCopy = pHello;
pCopy->AddRef();
OtherApp();
pCopy->Hello();
pCopy->Release();
}
看起来好像无懈可击,但是假设OtherApp中抛出了异常,那么pCopy->Release不就被跳过去了吗?
幸好,所有的问题都从简单到复杂,再从复杂到简单的,因为我们有CComPtr!

CComPtr被称为智能指针,是ATL提供的一个模版类,能够从语法上自动完成AddRef和Release。(源代码在atlbase.h中)
CComPtr的用法很简单,以IHello*为例,将程序中所有接口指针类型(除了参数),都使用CComPtr<IHello> 代替即可。即程序中除了参数之外,再也不要使用IHello*,全部以CComPtr<IHello>代替。
CComPtr的用法和普通COM指针几乎一样,另外使用中有以下几点需要注意。
1. CComPtr已经保证了AddRef和Release的正确调用,所以不需要,也不能够再调用AddRef和Release。
2. 如果要释放一个智能指针,直接给它赋NULL值即可。(这一点要牢记曾因为没有设置为null而出错)
3. CComPtr本身析构的时候会释放COM指针。
4. 当对CComPtr使用&运算符(取指针地址)的时候,要确保CComPtr为NUL。(因为通过CComPtr的地址对CComPtr赋值时,不会自动调用AddRef,若不为NULL,则前面的指针不能释放,CComPtr会使用assert报警)
以刚才的程序为例:
void SomeApp( IHello * pHello )
{
CComPtr<IHello> pCopy = pHello;
OtherApp();
pCopy->Hello();
}
由于pCopy是一个局部的对象,所以即使OtherApp()抛出异常,pCopy也会被析构,指针能够被释放。
如果不想在程序临近发布前,还因为COM指针的引用计数造成崩溃的话,就牢记这一点吧:程序中除了参数之外,不要直接使用COM指针类型,一定要全部以CComPtr<IXXX>代替。

CComPtr对象作为参数进行 1.值传递 2.引用传递 3.做为返回值的注意事项

2011-10-18 13:10 43人阅读 评论(0) 收藏 举报

1.导致内存泄露的一种调用方式:

下面方法是错误的:
IA *pA=NULL;
p->QueryInterfaces(...,&pA);//从某个已有接口查询获取IA
CComPtr<IA> spA(pA)
QueryInterface方法会导致pA->AddRef被调用一次,CComPtr<IA>构造函数又会调用一次AddRef,而最后spA析构时只调用了一次Release,因此COM对象没有被销毁,内存泄露了。

 

 

正确做法如下:

    IA *pA=NULL;
    p->QueryInterfaces(...,&pA);
    CComPtr<IA> spA;
    spA.Attach(pA);


或者
    CComPtr<IA> spA(pA)
    p->QueryInterfaces(...,&pA.p);

 

2.CComPtr内部对引用类型产生Assert原因

 

不能使用的operator&
   //The assert on operator& usually indicates a bug.  If this is really
    //what is needed, however, take the address of the p member explicitly
.
    T** operator&() throw()
    {
        ATLASSERT(p==NULL);
        return &p;
    }

    当你的CComPtr的p成员变量(集成而来的)不为NULL时,debug模式下会弹出错误对话框。看看上面的注释,这个函数被设计用来防止对智能指针直接调用取地址操作符的。实在要用,请用这种方法:&sp.p

 

3.CComPtr内部operator*

operator*

    T& operator*() const
    {
        ATLENSURE(p!=NULL);
        return *p;
    }

    有了这个操作,我们就可以使得CComPtr拥有和普通指针同样的行为,通过*p来获得p所指对象的引用。

 

4.CComPtr内部operator T*

operator T*
    operator T*() const throw()
    {
        return p;
    }
    这是个类型转换操作。调用方法如下:
    CComPtr<IUnknown> sp=...
    IUnknown* p=(IUnknown*)sp;

 

5.CComPtr内部CopyTo

CopyTo
_Check_return_ HRESULT CopyTo(_Deref_out_opt_ T** ppT) throw()
    {
        ATLASSERT(ppT != NULL);
        if (ppT == NULL)
            return E_POINTER;
        *ppT = p;
        if (p)
            p->AddRef();
        return S_OK;
    }
    将自己的接口拷贝个参数指针,并调用AddRef。

6.CComPtr内部Attach和Detach方法

    void Attach(_In_opt_ T* p2) throw()
    {
        if (p)
            p->Release();
        p = p2;
    }
    // Detach the interface (does not Release)
    T* Detach() throw()
    {
        T* pt = p;
        p = NULL;
        return pt;
    }

    Attach方法先释放原先p所指接口,然后接受新接口,注意,不会导致AddRef调用。
    Detach方法将p设置为NULLL,然后返回接口。如果外部调用需要保存返回的接口,否则就遗失了。

0

  • 评论加载中,请稍候...
发评论

    发评论

    以上网友发言只代表其个人观点,不代表新浪网的观点或立场。

      

    新浪BLOG意见反馈留言板 电话:4000520066 提示音后按1键(按当地市话标准计费) 欢迎批评指正

    新浪简介 | About Sina | 广告服务 | 联系我们 | 招聘信息 | 网站律师 | SINA English | 会员注册 | 产品答疑

    新浪公司 版权所有