Click here to Skip to main content
Click here to Skip to main content

A COM Smart Pointer

, 22 Feb 2006
Rate this:
Please Sign up or sign in to vote.
A wrapper class to any COM interface pointer.

Introduction

CComPtr wraps any interface pointer and will call AddRef() and Release() properly. That is, you don't need to worry about controlling the lifetime of your interface pointer.

Details

  1. ATL does provide a Smart Pointer class named CComQIPtr. But it uses some ATL related funtion so that it can be used only in an ATL environment.
  2. VC does provide _com_ptr_t & _bstr_ptr_t keywords to provide some kind of a wrapper. But it depends on the MS VC compiler, without which you can benefit.
  3. My CComPtr provides compiler unrelated features to wrap any interface pointer except IUnknown. Later I will explain why this limitation comes.

Illustration

Note: INTERFACE and piid are passed into the class CComPtr through template parameters.

CComPtr has four constructors to meet different requirement.

  • CComPtr()

Simply constructor, do nothing.

  • CComPtr(INTERFACE* lPtr)

Construct a new CComPtr object with an existing interface pointer. After that this new CComPtr object can be used as interface pointer itself.

  • CComPtr(IUnknown* pIUnknown, IID iid)

Construct a new CComPtr object with an IUnknown pointer and an IID, which represents the interface you are interested in. Internally constructor will call pIUnknown->QueryInterface to fetch interface pointer according to the IID.

  • CComPtr(const CComPtr<INTERFACE, piid>& RefComPtr)

This contsructor takes another existing CComPtr object as parameter. After that, clone the old CComPtr object.

CComPtr has one destructor, which will release interface pointer.

~CComPtr(){ if (m_Ptr) { m_Ptr->Release(); m_Ptr = NULL; } }

CComPtr has five operators.

  • (a) Operator INTERFACE* : Returns interface pointer wrapped by class CComPtr.

Example:

CComPtr<IWavePciStream> m_wavePciStreamPtr; 
IWavePciStream* pWavePciStream = (IWavePciStream*)m_wavePciStreamPtr;
  • (b) Operator *: Used to fetch interface object wrapped by class CComPtr.

Example:

CComPtr<IWavePciStream> m_wavePciStreamPtr; 
IWavePciStream wavePciStream = *m_wavePciStreamPtr;
  • (c) Operator &: Used to fetch the pointer to interface pointer wrapped by class CComPtr.

Example:

CComPtr<IWavePciStream> m_wavePciStreamPtr; 
IWavePciStream** ppWavePciStream = &m_wavePciStreamPtr;
  • (d) Operator -> : Used to make CComPtr object act as a TRUE interface pointer.

Example

CComPtr<IWavePciStream> m_wavePciStreamPtr; 
m_wavePciStreamPtr->AnyPciStreamMethods();
  • (e) Operator = : Used to transfer an exsiting interface pointer information to a new CComPtr object. This operator has three different parameter list.
    1. In parameter is INTERFACE*
    2. In parameter is another CComPtr object.
    3. In parameter is an interface pointer to IUnknown, which will be used to query other interface pointer defined by piid.

CComPtr has another three methods.

  • Attach : Used to attach an existing interface pointer to a CComPtr object.
  • Detach : Used to detach interface pointer from a CComPtr object.
  • Release : Used to release wrapped interface pointer explicitly.

CComPtr is implemented in pure C++. That is, it does not depend on any specific C/C++ compiler and can be compiled under any ANSI C/C++ compliant compiler. I have tested in VC++ 6.0. I do believe it works in GNU C/C++ and MAC CodeWarrior.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

About the Author

Skeeter
Program Manager Microsoft
China China
Graduated from Shanghai Tongji university in 1997 with bachelor degree in computer science, Wenbin got his first job as a system engineer at Bell Alcatel Mobile Shanghai office responsible for telcom-class mobile system development and deployment. Since then, Wenbin has in turn worked for Intel and Microsoft both inside and outside China, first as senior engineer, later project manager and then senior product manager.
 
With 15-year experience working with the world top IT companies, Wenbin has developed solid skill in C/C++, C#, Java, software engineering, agile development, etc, and multiple talents in product management, public presentation and speech, etc. He has always been an active member at PMI (Project Management Institution) and a regular lecture at Intel Developer Forum, Microsoft TechED conference as well as many other world-class industrial conferences. His wide-ranged industrial practice and high-level personal maturity have made him one of the best in public speech and professional training.
 
Over the years, Wenbin has cultivated his very own style in public speech, which is considered informative, engaging and refined. Since last year, Wenbin has also taken new adventure in project and product management consulting business and has proven high capacity through his work with many local emergent IT firms. Wenbin’s specialty in management consulting is on project management methodologies and processes, project management tools (e.g. MS Project), and team recruitment, build, and motivation.
 
In addition, Wenbin has received many professional qualifications including MCSE (Microsoft Certified System Engineer), MCSD (Microsoft Certified System Developer), MCDBA (Microsoft Certified Database Administrator), SCJP 2 (Sun Certified Java Programmer 2), and PMP (PMI Certified Project Management Professional). On top of that, Wenbin has got several on-duty inventions and one of them was successfully patented by United States Patent and Trademark Office.

Comments and Discussions

 
NewsReconsider your stuff [modified] Pinmembercnstrnd18-Oct-06 15:19 
Pointing goldsam was wrong doesn't prove you right. In fact, your wrapper is flawed in many ways. To state what a lot of your readers have already noticed :
 
- In all you accessors, you return your inner interface pointer. It ruins the whole encapsulation purpose intended by any smart-pointer/reference/handle. You should return *this; as a reference to self.
 
- Mixing run-time and compile-time use of the IID doesn't make sense. The IID should be statically available within your class. There is no need for a CComPtr(IUnknown* pIUnknown, IID iid) copy constructor. By the way, your implementation is not even consistent since you don't supply an operator= (IUnknown* pIUnknown, IID iid).
 
- operator* is irrevelant. COM interfaces are abstract thus not supposed to be dereferenced to their underlying struct. operator-> is sufficient.
 
- Implicit cast to the inner interface pointer is questionnable. The code you write, based on that wrapper, doesn't need such convertion. When giving away the actual interface to other APIs, a simple GetRawInterface() accessor is generally preferred.
 
- IsEqualObject should be redesigned to a symetrical operator== not only for cosmetics but because you MUST query for the address of BOTH the IUnknown. Another thing : you seem to prefer to call QueryInterface and Release on different interface pointers. This only obfuscate your code. Regarding IUnknown that ALL interfaces must implement, a COM object MUST behave the exact same way whatever interface the client use to access that particular object.
 
- Over ASSERTing every statement and setting m_Ptr to NULL in every way possible doesn't make your code more robust, it only show quite clearly you're not confident with how you're doing things.
 
- Talking about robustness, overloading operator& is awful : no well designed wrapper exposes its implementation details.
 
- You might also consider to make your class follow the RAII idiom so it can't be in a inconsistent state.
 
- And it goes on ...
 
To summer it up, while the use of smart-pointers is meant to be simple and natural, these little beasts are difficult to implement correctly and need very special care. See ?
 
It would have been a simple matter of respect to FIX your code when kind people took time to review it and pointed mistakes. Jumping on the first attempt of flamming just adds up to the pollution, your code included ... sorry. Writing articles here isn't about teaching, it is about sharing experiences so everybody can learn, you're included, not the other way around.

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Mobile
Web04 | 2.8.140721.1 | Last Updated 22 Feb 2006
Article Copyright 2001 by Skeeter
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid