COM学习笔记

 

COM 学习笔记

康  林 2004年11月

关键词：组件、接口、动态链接库、注册表、CLSID、GUID、IID、UUID

1. 概念：

   1. 类型库：

   2. 组件：是一个接口的集合。

   3. 接口：是一个包含一个函数接针数组的内存结构。每一个数组元素包含的是一个由组件所实现的函数的地址。

      组件是接口的集合,接口是函数的集合。

2. QueryInterface 的实现规则:

   1. QueryInterface 返回的总是同一个 IUnknown 指针。

   2. 若客户曾经获得过某个接口，那么它将总能获取此接口。

   3. 客户可以再次获得已经拥有的接口。

   4. 客户可以返回到起始接口。

   5. 若能够从某个接口获得某按按特定接口，那么可以从任意接口都将可以获得此接口。

3. ProgID 与 CLSID的转换：

   1. ProgIDFromCLSID
      HRESULT CLSIDFromProgID(
  LPCOLESTR lpszProgID,  //Pointer to the ProgID
  LPCLSID pclsid         //Pointer to the CLSID
);

   2. CLSIDFromProgID
      WINOLEAPI ProgIDFromCLSID(
  REFCLSID clsid,  //CLSID for which the ProgID is requested
  LPOLESTR * lplpszProgID
                   //Address of output variable that receives a
                   // pointer to the requested ProgID string
);
 

4. CLSID 与字符串的转换：

   1. CLSIDFromString
HRESULT CLSIDFromString(
  LPOLESTR lpsz,  //Pointer to the string representation of the CLSID
  LPCLSID pclsid  //Pointer to the CLSID
);

   2. StringFromCLSID
      WINOLEAPI StringFromCLSID(
  REFCLSID rclsid, //CLSID to be converted
  LPOLESTR * ppsz  //Address of output variable that receives a
                   // pointer to the resulting string
);

   3. StringFromGUID2
      int StringFromGUID2(
  REFGUID rguid,  //Interface identifier to be converted
  LPOLESTR lpsz,  //Pointer to the resulting string on return
  int cchMax       //Character count of string at lpsz
);
 

   4. StringFromIID
      WINOLEAPI StringFromIID(
  REFIID rclsid,     //Interface identifier to be converted
  LPOLESTR * lplpsz  //Address of output variable that receives a
                     // pointer to the resulting string
);

   5. IIDFromString
      WINOLEAPI IIDFromString(
  LPOLESTR lpsz,  //Pointer to the string representation of the IID
  LPIID lpiid     //Pointer to the requested IID on return
);

5. 注册：

   1. 用程序注册：regsvr32.exe

   2. 调用动态函数库中的注册函数：DllRegisterServer

   3. 调用动态函数库中的反注册函数:DllUnregisterServer

6. COM库函数:

   1. CoCreateInstance
        STDAPI CoCreateInstance(
     REFCLSID rclsid,     //Class identifier (CLSID) of the object
     LPUNKNOWN pUnkOuter, //Pointer to whether object is or isn't part
                            // of an aggregate
     DWORD dwClsContext,  //Context for running executable code
     REFIID riid,         //Reference to the identifier of the interface
     LPVOID * ppv         //Address of output variable that receives
                           // the interface pointer requested in riid
  );
CoCreateInstance 实际上是调用 CoGetClassObject 实现的。CoGetClassObject 将在注册表中查找指定的组件。找到之后，它将装载实现此组件的 DLL（用 CoLoadLibrary)。装载成功之后，它将调用在 DLL 服务器中的实现的 DllGetClassObject。此函数的作用是创建相应的类厂。另外 DllGetClassObject 还将查询 IClassFactory 接口，并将其返回给 CoCreateInstance。然后，CoCreatInstnce 将使用此接口来调用 IClassFactory::CreateInstance 函数。并查询指 CoCreateInstance 参数 riid 中指定的接口。在得到了此接口之后，CoCreateInstance 将释放相应的类厂并将此接口的指针返回给客户。然后客户就能使用此指针来调用组件中的某个方法了。

   2. CoGetClassObject
      STDAPI CoGetClassObject(
  REFCLSID rclsid,  //CLSID associated with the class object
  DWORD dwClsContext,
                    //Context for running executable code
  COSERVERINFO * pServerInfo,
                    //Pointer to machine on which the object is to
                    // be instantiated
  REFIID riid,      //Reference to the identifier of the interface
  LPVOID * ppv      //Address of output variable that receives the
                    // interface pointer requested in riid
);

   3. CoFreeUnusedLibraries：释放不再使用的DLL
       
7. 包容与聚合：

8. 接口指针类(智能接口指针):

   1. ATL中有 CComPrt 和 CComQIprt(#include <ATLBASE.H>)

      template <class T> class CComPtr { public: typedef T _PtrClass; 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(); } void Release() { IUnknown* pTemp = p; if (pTemp) { p = NULL; pTemp->Release(); } } operator T*() const { return (T*)p; } T& operator*() const { ATLASSERT(p!=NULL); return *p; } //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&() { ATLASSERT(p==NULL); return &p; } _NoAddRefReleaseOnCComPtr<T>* operator->() const { ATLASSERT(p!=NULL); return (_NoAddRefReleaseOnCComPtr<T>*)p; } T* operator=(T* lp) { return (T*)AtlComPtrAssign((IUnknown**)&p, lp); } T* operator=(const CComPtr<T>& lp) { return (T*)AtlComPtrAssign((IUnknown**)&p, lp.p); } bool operator!() const { return (p == NULL); } bool operator<(T* pT) const { return p < pT; } bool operator==(T* pT) const { return p == pT; } // Compare two objects for equivalence bool IsEqualObject(IUnknown* pOther) { if (p == NULL && pOther == NULL) return true; // They are both NULL objects if (p == NULL || pOther == NULL) return false; // One is NULL the other is not CComPtr<IUnknown> punk1; CComPtr<IUnknown> punk2; p->QueryInterface(IID_IUnknown, (void**)&punk1); pOther->QueryInterface(IID_IUnknown, (void**)&punk2); return punk1 == punk2; } void Attach(T* p2) { if (p) p->Release(); p = p2; } T* Detach() { T* pt = p; p = NULL; return pt; } HRESULT CopyTo(T** ppT) { ATLASSERT(ppT != NULL); if (ppT == NULL) return E_POINTER; *ppT = p; if (p) p->AddRef(); return S_OK; } HRESULT SetSite(IUnknown* punkParent) { return AtlSetChildSite(p, punkParent); } HRESULT Advise(IUnknown* pUnk, const IID& iid, LPDWORD pdw) { return AtlAdvise(p, pUnk, iid, pdw); } HRESULT CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL) { ATLASSERT(p == NULL); return ::CoCreateInstance(rclsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&p); } HRESULT CoCreateInstance(LPCOLESTR szProgID, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL) { CLSID clsid; HRESULT hr = CLSIDFromProgID(szProgID, &clsid); ATLASSERT(p == NULL); if (SUCCEEDED(hr)) hr = ::CoCreateInstance(clsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&p); return hr; } template <class Q> HRESULT QueryInterface(Q** pp) const { ATLASSERT(pp != NULL && *pp == NULL); return p->QueryInterface(__uuidof(Q), (void**)pp); } T* p; }; template <class T, const IID* piid = &__uuidof(T)> class CComQIPtr { public: typedef T _PtrClass; CComQIPtr() { p=NULL; } CComQIPtr(T* lp) { if ((p = lp) != NULL) p->AddRef(); } CComQIPtr(const CComQIPtr<T,piid>& lp) { if ((p = lp.p) != NULL) p->AddRef(); } CComQIPtr(IUnknown* lp) { p=NULL; if (lp != NULL) lp->QueryInterface(*piid, (void **)&p); } ~CComQIPtr() { if (p) p->Release(); } void Release() { IUnknown* pTemp = p; if (pTemp) { p = NULL; pTemp->Release(); } } operator T*() const { return p; } T& operator*() const { ATLASSERT(p!=NULL); return *p; } //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&() { ATLASSERT(p==NULL); return &p; } _NoAddRefReleaseOnCComPtr<T>* operator->() const { ATLASSERT(p!=NULL); return (_NoAddRefReleaseOnCComPtr<T>*)p; } T* operator=(T* lp) { return (T*)AtlComPtrAssign((IUnknown**)&p, lp); } T* operator=(const CComQIPtr<T,piid>& lp) { return (T*)AtlComPtrAssign((IUnknown**)&p, lp.p); } T* operator=(IUnknown* lp) { return (T*)AtlComQIPtrAssign((IUnknown**)&p, lp, *piid); } bool operator!() const { return (p == NULL); } bool operator<(T* pT) const { return p < pT; } bool operator==(T* pT) const { return p == pT; } // Compare two objects for equivalence bool IsEqualObject(IUnknown* pOther) { if (p == NULL && pOther == NULL) return true; // They are both NULL objects if (p == NULL || pOther == NULL) return false; // One is NULL the other is not CComPtr<IUnknown> punk1; CComPtr<IUnknown> punk2; p->QueryInterface(IID_IUnknown, (void**)&punk1); pOther->QueryInterface(IID_IUnknown, (void**)&punk2); return punk1 == punk2; } void Attach(T* p2) { if (p) p->Release(); p = p2; } T* Detach() { T* pt = p; p = NULL; return pt; } HRESULT CopyTo(T** ppT) { ATLASSERT(ppT != NULL); if (ppT == NULL) return E_POINTER; *ppT = p; if (p) p->AddRef(); return S_OK; } HRESULT SetSite(IUnknown* punkParent) { return AtlSetChildSite(p, punkParent); } HRESULT Advise(IUnknown* pUnk, const IID& iid, LPDWORD pdw) { return AtlAdvise(p, pUnk, iid, pdw); } HRESULT CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL) { ATLASSERT(p == NULL); return ::CoCreateInstance(rclsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&p); } HRESULT CoCreateInstance(LPCOLESTR szProgID, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL) { CLSID clsid; HRESULT hr = CLSIDFromProgID(szProgID, &clsid); ATLASSERT(p == NULL); if (SUCCEEDED(hr)) hr = ::CoCreateInstance(clsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&p); return hr; } template <class Q> HRESULT QueryInterface(Q** pp) { ATLASSERT(pp != NULL && *pp == NULL); return p->QueryInterface(__uuidof(Q), (void**)pp); } T* p; }; //Specialization to make it work template<> class CComQIPtr<IUnknown, &IID_IUnknown> { public: typedef IUnknown _PtrClass; CComQIPtr() { p=NULL; } CComQIPtr(IUnknown* lp) { //Actually do a QI to get identity p=NULL; if (lp != NULL) lp->QueryInterface(IID_IUnknown, (void **)&p); } CComQIPtr(const CComQIPtr<IUnknown,&IID_IUnknown>& lp) { if ((p = lp.p) != NULL) p->AddRef(); } ~CComQIPtr() { if (p) p->Release(); } void Release() { IUnknown* pTemp = p; if (pTemp) { p = NULL; pTemp->Release(); } } operator IUnknown*() const { return p; } IUnknown& operator*() const { ATLASSERT(p!=NULL); return *p; } //The assert on operator& usually indicates a bug. If this is really //what is needed, however, take the address of the p member explicitly. IUnknown** operator&() { ATLASSERT(p==NULL); return &p; } _NoAddRefReleaseOnCComPtr<T>* operator->() const { ATLASSERT(p!=NULL); return (_NoAddRefReleaseOnCComPtr<T>*)p; } IUnknown* operator=(IUnknown* lp) { //Actually do a QI to get identity return (IUnknown*)AtlComQIPtrAssign((IUnknown**)&p, lp, IID_IUnknown); } IUnknown* operator=(const CComQIPtr<IUnknown,&IID_IUnknown>& lp) { return (IUnknown*)AtlComPtrAssign((IUnknown**)&p, lp.p); } bool operator!() const { return (p == NULL); } bool operator<(IUnknown* pT) const { return p < pT; } bool operator==(IUnknown* pT) const { return p == pT; } // Compare two objects for equivalence bool IsEqualObject(IUnknown* pOther) { if (p == NULL && pOther == NULL) return true; // They are both NULL objects if (p == NULL || pOther == NULL) return false; // One is NULL the other is not CComPtr<IUnknown> punk1; CComPtr<IUnknown> punk2; p->QueryInterface(IID_IUnknown, (void**)&punk1); pOther->QueryInterface(IID_IUnknown, (void**)&punk2); return punk1 == punk2; } IUnknown* Detach() { IUnknown* pt = p; p = NULL; return pt; } HRESULT CopyTo(T** ppT) { ATLASSERT(ppT != NULL); if (ppT == NULL) return E_POINTER; *ppT = p; if (p) p->AddRef(); return S_OK; } HRESULT SetSite(IUnknown* punkParent) { return AtlSetChildSite(p, punkParent); } HRESULT Advise(IUnknown* pUnk, const IID& iid, LPDWORD pdw) { return AtlAdvise(p, pUnk, iid, pdw); } HRESULT CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL) { ATLASSERT(p == NULL); return ::CoCreateInstance(rclsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&p); } HRESULT CoCreateInstance(LPCOLESTR szProgID, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL) { CLSID clsid; HRESULT hr = CLSIDFromProgID(szProgID, &clsid); ATLASSERT(p == NULL); if (SUCCEEDED(hr)) hr = ::CoCreateInstance(clsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&p); return hr; } template <class Q> HRESULT QueryInterface(Q** pp) { ATLASSERT(pp != NULL && *pp == NULL); return p->QueryInterface(__uuidof(Q), (void**)pp); } IUnknown* p; }; #define com_cast CComQIPtr

   2. MFC中有CIP(#include <afxcom_.h>)

      // This is a part of the Microsoft Foundation Classes C++ library. // Copyright (C) 1992-1998 Microsoft Corporation // All rights reserved. // // This source code is only intended as a supplement to the // Microsoft Foundation Classes Reference and related // electronic documentation provided with the library. // See these sources for detailed information regarding the // Microsoft Foundation Classes product. ///////////////////////////////////////////////////////////////////////////// // AFXCOM_.H // // THIS FILE IS FOR MFC IMPLEMENTATION ONLY. #ifndef __AFXCOM_H__ #define __AFXCOM_H__ #ifndef _OBJBASE_H_ #include <objbase.h> #endif ///////////////////////////////////////////////////////////////////////////// #ifdef _AFX_MINREBUILD #pragma component(minrebuild, off) #endif #ifndef _AFX_FULLTYPEINFO #pragma component(mintypeinfo, on) #endif ///////////////////////////////////////////////////////////////////////////// #ifndef _AFX_NOFORCE_LIBS #pragma comment(lib, "uuid.lib") #endif ///////////////////////////////////////////////////////////////////////////// #ifdef _AFX_PACKING #pragma pack(push, _AFX_PACKING) #endif #ifndef ASSERT #ifndef _INC_CRTDBG #include <crtdbg.h> #endif // _INC_CRTDBG #define ASSERT(x) _ASSERT(x) #endif // ASSERT ///////////////////////////////////////////////////////////////////////////// template<class _Interface, const IID* _IID> class _CIP { public: // Declare interface type so that the type may be available outside // the scope of this template. typedef _Interface Interface; // When the compiler supports references in template params, // _CLSID will be changed to a reference. To avoid conversion // difficulties this function should be used to obtain the // CLSID. static const IID& GetIID() { ASSERT(_IID != NULL); return *_IID; } // Construct empty in preperation for assignment. _CIP(); // Copy the pointer and AddRef(). _CIP(const _CIP& cp) : _pInterface(cp._pInterface) { _AddRef(); } // Saves and AddRef()'s the interface _CIP(Interface* pInterface) : _pInterface(pInterface) { _AddRef(); } // Copies the pointer. If bAddRef is TRUE, the interface will // be AddRef()ed. _CIP(Interface* pInterface, BOOL bAddRef) : _pInterface(pInterface) { if (bAddRef) { ASSERT(pInterface != NULL); _AddRef(); } } // Calls CoCreateClass with the provided CLSID. _CIP(const CLSID& clsid, DWORD dwClsContext = CLSCTX_INPROC_SERVER) : _pInterface(NULL) { CreateObject(clsid, dwClsContext); } // Calls CoCreateClass with the provided CLSID retrieved from // the string. _CIP(LPOLESTR str, DWORD dwClsContext = CLSCTX_INPROC_SERVER) : _pInterface(NULL) { CreateObject(str, dwClsContext); } // Saves and AddRef()s the interface. _CIP& operator=(Interface* pInterface) { if (_pInterface != pInterface) { Interface* pOldInterface = _pInterface; _pInterface = pInterface; _AddRef(); if (pOldInterface != NULL) pOldInterface->Release(); } return *this; } // Copies and AddRef()'s the interface. _CIP& operator=(const _CIP& cp) { return operator=(cp._pInterface); } // Releases any current interface and loads the class with the // provided CLSID. _CIP& operator=(const CLSID& clsid) { CreateObject(clsid); return *this; } // Calls CoCreateClass with the provided CLSID retrieved from // the string. _CIP& operator=(LPOLESTR str) { CreateObject(str); return *this; } ~_CIP(); // Saves/sets the interface without AddRef()ing. This call // will release any previously aquired interface. void Attach(Interface* pInterface) { _Release(); _pInterface = pInterface; } // Saves/sets the interface only AddRef()ing if bAddRef is TRUE. // This call will release any previously aquired interface. void Attach(Interface* pInterface, BOOL bAddRef) { _Release(); _pInterface = pInterface; if (bAddRef) { ASSERT(pInterface != NULL); pInterface->AddRef(); } } // Simply NULL the interface pointer so that it isn't Released()'ed. void Detach() { ASSERT(_pInterface); _pInterface = NULL; } // Return the interface. This value may be NULL operator Interface*() const { return _pInterface; } // Queries for the unknown and return it operator IUnknown*() { return _pInterface; } // Provides minimal level assertion before use. operator Interface&() const { ASSERT(_pInterface); return *_pInterface; } // Allows an instance of this class to act as though it were the // actual interface. Also provides minimal assertion verification. Interface& operator*() const { ASSERT(_pInterface); return *_pInterface; } // Returns the address of the interface pointer contained in this // class. This is useful when using the COM/OLE interfaces to create // this interface. Interface** operator&() { _Release(); _pInterface = NULL; return &_pInterface; } // Allows this class to be used as the interface itself. // Also provides simple assertion verification. Interface* operator->() const { ASSERT(_pInterface != NULL); return _pInterface; } // This operator is provided so that simple boolean expressions will // work. For example: "if (p) ...". // Returns TRUE if the pointer is not NULL. operator BOOL() const { return _pInterface != NULL; } // Returns TRUE if the interface is NULL. // This operator will be removed when support for type bool // is added to the compiler. BOOL operator!() { return _pInterface == NULL; } // Provides assertion verified, Release()ing of this interface. void Release() { ASSERT(_pInterface != NULL); _pInterface->Release(); _pInterface = NULL; } // Provides assertion verified AddRef()ing of this interface. void AddRef() { ASSERT(_pInterface != NULL); _pInterface->AddRef(); } // Another way to get the interface pointer without casting. Interface* GetInterfacePtr() const { return _pInterface; } // Loads an interface for the provided CLSID. // Returns an HRESULT. Any previous interface is released. HRESULT CreateObject( const CLSID& clsid, DWORD dwClsContext = CLSCTX_INPROC_SERVER) { _Release(); HRESULT hr = CoCreateInstance(clsid, NULL, dwClsContext, GetIID(), reinterpret_cast<void**>(&_pInterface)); ASSERT(SUCCEEDED(hr)); return hr; } // Creates the class specified by clsidString. clsidString may // contain a class id, or a prog id string. HRESULT CreateObject( LPOLESTR clsidString, DWORD dwClsContext=CLSCTX_INPROC_SERVER) { ASSERT(clsidString != NULL); CLSID clsid; HRESULT hr; if (clsidString[0] == '{') hr = CLSIDFromString(clsidString, &clsid); else hr = CLSIDFromProgID(clsidString, &clsid); ASSERT(SUCCEEDED(hr)); if (FAILED(hr)) return hr; return CreateObject(clsid, dwClsContext); } // Performs a QI on pUnknown for the interface type returned // for this class. The interface is stored. If pUnknown is // NULL, or the QI fails, E_NOINTERFACE is returned and // _pInterface is set to NULL. HRESULT QueryInterface(IUnknown* pUnknown) { if (pUnknown == NULL) // Can't QI NULL { operator=(static_cast<Interface*>(NULL)); return E_NOINTERFACE; } // Query for this interface Interface* pInterface; HRESULT hr = pUnknown->QueryInterface(GetIID(), reinterpret_cast<void**>(&pInterface)); if (FAILED(hr)) { // If failed intialize interface to NULL and return HRESULT. Attach(NULL); return hr; } // Save the interface without AddRef()ing. Attach(pInterface); return hr; } private: // Releases only if the interface is not null. // The interface is not set to NULL. void _Release() { if (_pInterface != NULL) _pInterface->Release(); } // AddRefs only if the interface is not NULL void _AddRef() { if (_pInterface != NULL) _pInterface->AddRef(); } // The Interface. Interface* _pInterface; }; // class _CIP template<class _Interface, const IID* _IID> _CIP<_Interface, _IID>::_CIP<_Interface, _IID>() : _pInterface(NULL) { } template<class _Interface, const IID* _IID> _CIP<_Interface, _IID>::~_CIP<_Interface, _IID>() { // If we still have an interface then Release() it. The interface // may be NULL if Detach() has previosly been called, or if it was // never set. _Release(); } template<class _Interface, const IID* _IID> class CIP : public _CIP<_Interface, _IID> { public: // Simplified name for base class and provide derived classes // access to base type typedef _CIP<_Interface, _IID> BC; // Provideds derived classes access to the interface type. typedef _Interface Interface; // Construct empty in preperation for assignment. CIP() { } ~CIP(); // Copy the pointer and AddRef(). CIP(const CIP& cp) : _CIP<_Interface, _IID>(cp) { } // Saves and AddRef()s the interface. CIP(Interface* pInterface) : _CIP<_Interface, _IID>(pInterface) { } // Saves the interface and AddRef()s only if bAddRef is TRUE. CIP(Interface* pInterface, BOOL bAddRef) : _CIP<_Interface, _IID>(pInterface, bAddRef) { } // Queries for this interface. CIP(IUnknown* pUnknown) { if (pUnknown == NULL) return; Interface* pInterface; HRESULT hr = pUnknown->QueryInterface(GetIID(), reinterpret_cast<void**>(&pInterface)); ASSERT(SUCCEEDED(hr)); Attach(pInterface); } // Creates the interface from the CLSID. CIP(const CLSID& clsid) : _CIP<_Interface, _IID>(clsid) { } // Creates the interface from the CLSID. CIP(LPOLESTR str) : _CIP<_Interface, _IID>(str) { } // Copies and AddRef()'s the interface. CIP& operator=(const CIP& cp) { _CIP<_Interface, _IID>::operator=(cp); return *this; } // Saves and AddRef()s the interface. CIP& operator=(Interface* pInterface) { _CIP<_Interface, _IID>::operator=(pInterface); return *this; } CIP& operator=(IUnknown* pUnknown) { HRESULT hr = QueryInterface(pUnknown); ASSERT(SUCCEEDED(hr)); return *this; } // Releases any current interface and loads the class with the // provided CLSID. CIP& operator=(const CLSID& clsid) { _CIP<_Interface, _IID>::operator=(clsid); return *this; } // Releases any current interface and loads the class with the // provided CLSID. CIP& operator=(LPOLESTR str) { _CIP<_Interface, _IID>::operator=(str); return *this; } }; // class CIP template<class _Interface, const IID* _IID> CIP<_Interface, _IID>::~CIP() { } #if _MSC_VER > 1020 template<> #endif class CIP<IUnknown, &IID_IUnknown> : public _CIP<IUnknown, &IID_IUnknown> { public: // Simplified name for base class and provide derived classes // access to base type typedef _CIP<IUnknown, &IID_IUnknown> BC; // Provideds derived classes access to the interface type. typedef IUnknown Interface; // Construct empty in preperation for assignment. CIP() { } // Copy the pointer and AddRef(). CIP(const CIP& cp) : _CIP<IUnknown, &IID_IUnknown>(cp) { } // Saves and AddRef()s the interface. CIP(Interface* pInterface) : _CIP<IUnknown, &IID_IUnknown>(pInterface) { } // Saves and then AddRef()s only if bAddRef is TRUE. CIP(Interface* pInterface, BOOL bAddRef) : _CIP<IUnknown, &IID_IUnknown>(pInterface, bAddRef) { } // Creates the interface from the CLSID. CIP(const CLSID& clsid) : _CIP<IUnknown, &IID_IUnknown>(clsid) { } // Creates the interface from the CLSID. CIP(LPOLESTR str) : _CIP<IUnknown, &IID_IUnknown>(str) { } // Copies and AddRef()'s the interface. CIP& operator=(const CIP& cp) { _CIP<IUnknown, &IID_IUnknown>::operator=(cp); return *this; } // Saves and AddRef()s the interface. The previously saved // interface is released. CIP& operator=(Interface* pInterface) { _CIP<IUnknown, &IID_IUnknown>::operator=(pInterface); return *this; } // Releases any current interface and loads the class with the // provided CLSID. CIP& operator=(const CLSID& clsid) { _CIP<IUnknown, &IID_IUnknown>::operator=(clsid); return *this; } // Releases any current interface and loads the class with the // provided CLSID. CIP& operator=(LPOLESTR str) { _CIP<IUnknown, &IID_IUnknown>::operator=(str); return *this; } // Queries for the unknown and return it operator IUnknown*() { return GetInterfacePtr(); } // Verifies that pUnknown is not null and performs assignment. HRESULT QueryInterface(IUnknown* pUnknown) { _CIP<IUnknown, &IID_IUnknown>::operator=(pUnknown); return pUnknown != NULL ? S_OK : E_NOINTERFACE; } }; // CIP<IUnknown, &IID_IUnknown> #define IPTR(x) CIP<x, &IID_##x> #define DEFINE_IPTR(x) typedef IPTR(x) x##Ptr; ///////////////////////////////////////////////////////////////////////////// #ifdef _AFX_PACKING #pragma pack(pop) #endif #ifdef _AFX_MINREBUILD #pragma component(minrebuild, on) #endif #ifndef _AFX_FULLTYPEINFO #pragma component(mintypeinfo, off) #endif #endif // __AFXCOM_H__ /////////////////////////////////////////////////////////////////////////////

   3. 使用接口类的成员函数，用 . 操作符。例如：
      CComQIPtr <InterfaceClass, &IID> spIF;
      spIF.Release(); //释放接口指针
   4. 释放接口指针类(智能接口指针):
      CComQIPtr <InterfaceClass, &IID> spIF;
      spIF = NULL; //释放接口指针

9. C++包装类:(MFC OLE)

用嵌套类实现接口:

1. 在CCmdTarget类和其派生类定义中使用宏 DECLARE_INTERFACE_MAP() 声明接口映射表使用的一些静态成员以及两个成员函数；

   #ifdef _AFXDLL #define DECLARE_INTERFACE_MAP() / private: / static const AFX_INTERFACEMAP_ENTRY _interfaceEntries[]; / protected: / static AFX_DATA const AFX_INTERFACEMAP interfaceMap; / static const AFX_INTERFACEMAP* PASCAL _GetBaseInterfaceMap(); / virtual const AFX_INTERFACEMAP* GetInterfaceMap() const; / #else #define DECLARE_INTERFACE_MAP() / private: / static const AFX_INTERFACEMAP_ENTRY _interfaceEntries[]; / protected: / static AFX_DATA const AFX_INTERFACEMAP interfaceMap; / virtual const AFX_INTERFACEMAP* GetInterfaceMap() const; / #endif

2. 在类的实现文件中先定义接口的 IID
3. 在类的实现部分使用 BEGIN_INTERFACE_MAP、INTERFACE_PART 和 END_INTERFACE_MAP 宏定义接口映射表；

   #ifdef _AFXDLL #define BEGIN_INTERFACE_MAP(theClass, theBase) / const AFX_INTERFACEMAP* PASCAL theClass::_GetBaseInterfaceMap() / { return &theBase::interfaceMap; } / const AFX_INTERFACEMAP* theClass::GetInterfaceMap() const / { return &theClass::interfaceMap; } / AFX_COMDAT const AFX_DATADEF AFX_INTERFACEMAP theClass::interfaceMap = / { &theClass::_GetBaseInterfaceMap, &theClass::_interfaceEntries[0], }; / AFX_COMDAT const AFX_DATADEF AFX_INTERFACEMAP_ENTRY theClass::_interfaceEntries[] = / { / #else #define BEGIN_INTERFACE_MAP(theClass, theBase) / const AFX_INTERFACEMAP* theClass::GetInterfaceMap() const / { return &theClass::interfaceMap; } / AFX_COMDAT const AFX_DATADEF AFX_INTERFACEMAP theClass::interfaceMap = / { &theBase::interfaceMap, &theClass::_interfaceEntries[0], }; / AFX_COMDAT const AFX_DATADEF AFX_INTERFACEMAP_ENTRY theClass::_interfaceEntries[] = / { / #endif #define INTERFACE_PART(theClass, iid, localClass) / { &iid, offsetof(theClass, m_x##localClass) }, / #define INTERFACE_AGGREGATE(theClass, theAggr) / { NULL, offsetof(theClass, theAggr) }, / #define END_INTERFACE_MAP() / { NULL, (size_t)-1 } / }; /

   由这三步，实现接口映射（在 CCmdtarget 中,用接口映射表实现了 IUnknown->QueryInterface  操作）。

4. 为每一个接口定义嵌套类成员（定义接口）；
   BEGIN_INTERFACE_PART()

   #define BEGIN_INTERFACE_PART(localClass, baseClass) / class X##localClass : public baseClass / { / public: / STDMETHOD_(ULONG, AddRef)(); / STDMETHOD_(ULONG, Release)(); / STDMETHOD(QueryInterface)(REFIID iid, LPVOID* ppvObj); /

   
   INIT_INTERFACE_PART()定义了记录偏移量的数据成员 m_nOffset，并在嵌套类的构造函数中对 m_nOffwet 进行初始赋值。所以根据此偏移经计算得到父类的指针 pThis

   #define METHOD_PROLOGUE_EX(theClass, localClass) / theClass* pThis = ((theClass*)((BYTE*)this - m_nOffset)); / AFX_MANAGE_STATE(pThis->m_pModuleState) / pThis; // avoid warning from compiler /

   ，然后利用父类的成员函数。
   

   #ifndef _AFX_NO_NESTED_DERIVATION #define INIT_INTERFACE_PART(theClass, localClass) / size_t m_nOffset; / INIT_INTERFACE_PART_DERIVE(theClass, localClass) / #define INIT_INTERFACE_PART_DERIVE(theClass, localClass) / X##localClass() / { m_nOffset = offsetof(theClass, m_x##localClass); } / #else #define INIT_INTERFACE_PART(theClass, localClass) #define INIT_INTERFACE_PART_DERIVE(theClass, localClass) #endif

   STEMETHOD_()
   

   #define STDMETHOD(method) virtual HRESULT STDMETHODCALLTYPE method #define STDMETHOD_(type,method) virtual type STDMETHODCALLTYPE method

   END_INTERFACE_PART() 注意：这里会在类中定义一个成员变量： m_xLocallClass 和一个友员类 XlocaalClass

   #define END_INTERFACE_PART(localClass) / } m_x##localClass; / friend class X##localClass; /

5. 实现嵌套类。
   在方法中先用宏 METHOD_PROLOGUE_EX_(theClass, localClass) 得到父指针 pThis，然后实现方法。QueryInterface, AddRef, 和 Release 的实现。
    

   STDMETHODIMP_(ULONG) COleDropTarget::XDropTarget::AddRef() { METHOD_PROLOGUE_EX_(COleDropTarget, DropTarget) return pThis->ExternalAddRef(); } STDMETHODIMP_(ULONG) COleDropTarget::XDropTarget::Release() { METHOD_PROLOGUE_EX_(COleDropTarget, DropTarget) return pThis->ExternalRelease(); } STDMETHODIMP COleDropTarget::XDropTarget::QueryInterface( REFIID iid, LPVOID* ppvObj) { METHOD_PROLOGUE_EX_(COleDropTarget, DropTarget) return pThis->ExternalQueryInterface(&iid, ppvObj); }

6. COM 引出函数和类厂的实现。
   • 类厂

     COleObjectFactory cf ( CLSID_Math, // The object's CLSID RUNTIME_CLASS (CComClass), // Class representing the object FALSE, // Many clients, one EXE _T ("Math.Object") // The object's ProgID );

   • 定义一个内嵌的类厂对象，在类的定义中用 DECLARE_OLECREATE

     #define DECLARE_OLECREATE(class_name) / public: / static AFX_DATA COleObjectFactory factory; / static AFX_DATA const GUID guid; /

   • 实现类厂对象，在实现文件中用 IMPLEMENT_OLECREATE ,external_name :ProgID;class_name:CLSID

     #define IMPLEMENT_OLECREATE(class_name, external_name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) / AFX_DATADEF COleObjectFactory class_name::factory(class_name::guid, / RUNTIME_CLASS(class_name), FALSE, _T(external_name)); / AFX_COMDAT const AFX_DATADEF GUID class_name::guid = / { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }; /

建立连接点

1. 建立源对象，参见潘爱民的《COM原理及应用》的第 192 页的 6.4.3 节

   1. 用向导生成一个 DLL 工程，注意要选中自动化。见图

      点完成。向导自动在初始化函数中加入了下面的红色部分。

      BOOL CKeyInputApp::InitInstance() { CWinApp::InitInstance(); // 将所有 OLE 服务器(工厂)注册为运行。这将使 // OLE 库得以从其他应用程序创建对象。 COleObjectFactory::RegisterAll(); return TRUE; }

   2. 用向导加入一个从 CCmdTarget 派生的新类，见图：

      它自动完成了类厂的建立和 Disptach 接口。如下：

      头文件：

      #pragma once // CKeyInput 命令目标 class CKeyInput : public CCmdTarget { DECLARE_DYNCREATE(CKeyInput) public: CKeyInput(); virtual ~CKeyInput(); virtual void OnFinalRelease(); protected: DECLARE_MESSAGE_MAP() DECLARE_OLECREATE(CKeyInput) DECLARE_DISPATCH_MAP() DECLARE_INTERFACE_MAP() };

      实现文件：

      // CKeyInput.cpp : 实现文件 // #include "stdafx.h" #include "KeyInput.h" #include "CKeyInput.h" // CKeyInput IMPLEMENT_DYNCREATE(CKeyInput, CCmdTarget) CKeyInput::CKeyInput() { EnableAutomation(); // 为了使应用程序在 OLE 自动化对象处于活动状态时保持 // 运行，构造函数调用 AfxOleLockApp。 AfxOleLockApp(); } CKeyInput::~CKeyInput() { // 为了在用 OLE 自动化创建所有对象后终止应用程序， // 析构函数调用 AfxOleUnlockApp。 AfxOleUnlockApp(); } void CKeyInput::OnFinalRelease() { // 释放了对自动化对象的最后一个引用后，将调用 // OnFinalRelease。基类将自动 // 删除该对象。在调用该基类之前，请添加您的 // 对象所需的附加清除代码。 CCmdTarget::OnFinalRelease(); } BEGIN_MESSAGE_MAP(CKeyInput, CCmdTarget) END_MESSAGE_MAP() BEGIN_DISPATCH_MAP(CKeyInput, CCmdTarget) END_DISPATCH_MAP() // 注意: 我们添加 IID_IKeyInput 支持 //以支持来自 VBA 的类型安全绑定。此 IID 必须同附加到 .IDL 文件中的 //调度接口的 GUID 匹配。 // {87741D4A-7277-4D93-98F0-D116B995FD91} static const IID IID_IKeyInput = { 0x87741D4A, 0x7277, 0x4D93, { 0x98, 0xF0, 0xD1, 0x16, 0xB9, 0x95, 0xFD, 0x91 } }; BEGIN_INTERFACE_MAP(CKeyInput, CCmdTarget) INTERFACE_PART(CKeyInput, IID_IKeyInput, Dispatch) END_INTERFACE_MAP() // {7C6F1364-8C73-4335-B6FD-C61D53681573} IMPLEMENT_OLECREATE_FLAGS(CKeyInput, "KeyInput.KeyInput", afxRegApartmentThreading, 0x7c6f1364, 0x8c73, 0x4335, 0xb6, 0xfd, 0xc6, 0x1d, 0x53, 0x68, 0x15, 0x73) // CKeyInput 消息处理程序

       

   3. 建立连接点容器

      • 在实现文件中的接口映射表中定义：INTERFACE_PART(theClass, IID_IConnectionPointContainer, ConnPtContainer)

        BEGIN_INTERFACE_MAP(theClass, theBase) INTERFACE_PART(theClass, IID, Dispatch) //这是向导加的 INTERFACE_PART(theClass, IID_IConnectionPointContainer, ConnPtContainer) END_INTERFACE_MAP()

      • 在类 theClass 的构造函数中加入：
        EnableAutomation();
        EnableConnections();
   4. 建立连接点
      • 在头文件中声明连接点映射表：DELARE_CONNECTION_MAP()
      • 在实现文件中定义连接点的 IID 和 在 odl(idl) 文件中定义连接点接口
      • 在实现文件中定义连接点映射表：
        • BEGIN_CONNECTION_MAP(theClass, theBase)
        • CONNECTION_PART(theClass, IID, LocalClass)
        • END_CONNECTION_MAP()
      • 在头文件中定义连接点对象：
        • BEGIN_CONNECTION_PART(theClass,LocalClass)
        • CONNECTION_IID(IID)
        • END_CONNECTION_PART(LocalClass) 注意：这里会在类中定义一个成员变量： m_xLocallClass 和一个友员类 XlocaalClass
2. 实现接收器，参见 195 页的 6.4.4 节

    

   1. 加入 COM 库初始化函数：AfxOleInit()
   2. 加入接收器对象：
      • BEGIN_INTERFACE_PART(theEvent, IDispatch) //从 IDispatch 派生出来的
      • INIT_INTERFACE_PART(theClass, theEvent)
      • 接收器的方法：STDMETHOD(...)
      • END_INTERFACE_PART(theEvent)
   3. 实现接收器成员：Invoke 等。

用 ATL 实现接口

VC6.0

1. 建立 ATL 工程

    

   1. 操作步骤 步骤1：建立一个工作区(WorkSpace)。
      步骤2：在工作区中，建立一个 ATL 工程(Project)。示例程序叫 Simple1，并选择DLL方式，见图一。
      
      
      图一、建立 ATL DLL 工程
      
      　　Dynamic Link Library(DLL) 表示建立一个 DLL 的组件程序。
      　　Executable(EXE) 表示建立一个 EXE 的组件程序。
      　　Service(EXE) 表示建立一个服务程序，系统启动后就会加载并执行的程序。
      　　Allow merging of proxy/stub code 选择该项表示把“代理/存根”代码合并到组件程序中，否则需要单独编译，单独注册代理存根程序。代理/存根，这个是什么概念？还记得我们在 上回书 中介绍的吗？当调用者调用进程外或远程组件功能的时候，其实是代理/存根负责数据交换的。
   2. 增加的内容 增加的文件：
      ATLCOM.def:定义 DLL 的导出函数。
      ATLCOM.IDL:定义 COM 库和接口。
      

      import "oaidl.idl";
      import "ocidl.idl";
      
      [
      uuid(607C0BF2-5E09-42E7-A62F-407036FFAAD3),
      version(1.0),
      helpstring("ATLCOM 1.0 Type Library")
      ]
      library ATLCOMLib
      {
      importlib("stdole32.tlb");
      importlib("stdole2.tlb");
      
      };
       

      ATLCOM.CPP：实现了COM对象实例和动态库的入口和导出函数的实现。
      1. 对象映射表：
         BEGIN_OBJECT_MAP(ObjectMap)
         END_OBJECT_MAP()
      2. CComModule _Module;
      3. DllMain
      4. DllCanUnloadNow
      5. DllGetClassObject
      6. DllRegisterServer
      7. DllUnregistSever

       

      编译后增加的文件：
      1. ATLCOM_i.c:定义库的IID
      2. ATLCOM.H:这个编译前已有，但没有内容。内容是由MIDL编译IDL文件后产生的。
         

增加 ATL 对象类

1. 操作步骤 步骤1：菜单 Insert/New ATL Object...（或者用鼠标右键在 ClassView 卡片中弹出菜单）并选择Object 分类，选中 Simple Object 项目。见图二。
   
   
   图二、选择建立简单COM对象
   
   　　 Category Object 普通组件。其中可以选择的组件对象类型很多，但本质上，就是让向导帮我们默认加上一些接口。比如我们选 "Simple Object"，则向导给我们的组件加上 IUnknown 接口；我们选 "Internet Explorer Object"，则向导除了加上 IUnknown 接口外，再增加一个给 IE 所使用的 IObjectWithSite 接口。当然了，我们完全可以手工增加任何接口。
   　　 Category Controls ActiveX 控件。其中可以选择的 ActiveX 类型也很多。我们在后续的专门介绍 ActiveX 编程中再讨论。
   　　 Category Miscellaneous 辅助杂类组件。
   　　 Categroy Data Access 数据库类组件(我最讨厌数据库编程了，所以我也不会)。
   
   　　步骤2：增加自定义类 CFun(接口 IFun) ,见图三。
   
   
   图三、输入类中的各项名称
   　　 其实，我们只需要输入短名(Short Name)，其它的项目会自动填写。没什么多说的，只请大家注意一下 ProgID 项，默认的 ProgID 构造方式为“工程名.短名”。
   
   　　 步骤3：填写接口属性，见图四。
   
   图四、接口属性
   
   　　 Threading Model 选择组件支持的线程模型。COM 中的线程，我认为是最讨厌，最复杂的部分。COM 线程和公寓的概念，留待后续介绍。现在吗......大家都选 Apartment，它代表什么那？简单地说：当在线程中调用组件函数的时候，这些调用会排队进行。因此，这种模式下，我们可以暂时不用考虑同步的问题。(注1)
   　　 Interface 接口基本类型。Dual 表示支持双接口(注2)，这个非常 非常重要，非常非常常用，但我们今天不讲。Custom 表示自定义借口。 切记！切记！我们的这第一个 COM 程序中，一定要选择它！！！！（如果你选错了，请删除全部内容，重新来过。）
   　　 Aggregation 我们写的组件，将来是否允许被别人聚合(注3)使用。Only 表示必须被聚合才能使用，有点类似 C++ 中的纯虚类，你要是总工程师，只负责设计但不亲自写代码的话，才选择它。
   　　 Support ISupportErrorInfo 是否支持丰富信息的错误处理接口。以后就讲。
   　　 Support Connection Points 是否支持连接点接口（事件、回调）。以后就讲。
   　　 Free Threaded Marshaler 以后也不讲，就算打死你，我也不说！(注4)
   
   
2. 增加的内容 增加的文件：
   Fun.cpp:
   Fun.h:
   

   // Fun.h : Declaration of the CFun
   
   #ifndef __FUN_H_
   #define __FUN_H_
   
   #include "resource.h"       // main symbols
   
   /////////////////////////////////////////////////////////////////////////////
   // CFun
   class ATL_NO_VTABLE CFun : 
   	public CComObjectRootEx
         ,
   	public CComCoClass,
   	public IFun
   {
   public:
   	CFun()
   	{
   	}
   
   DECLARE_REGISTRY_RESOURCEID(IDR_FUN)
   
   DECLARE_PROTECT_FINAL_CONSTRUCT()
   
   BEGIN_COM_MAP(CFun)
   	COM_INTERFACE_ENTRY(IFun)
   END_COM_MAP()
   
   // IFun
   public:
   };
   
   #endif //__FUN_H_
   

   Fun.rgs:关于注册值：

   HKCR
   {
   	ATLCOM.Fun.1 = s 'Fun Class'
   	{
   		CLSID = s '{00B276CB-650D-4E84-8B8F-A005D4C06C7C}'
   	}
   	ATLCOM.Fun = s 'Fun Class'
   	{
   		CLSID = s '{00B276CB-650D-4E84-8B8F-A005D4C06C7C}'
   		CurVer = s 'ATLCOM.Fun.1'
   	}
   	NoRemove CLSID
   	{
   		ForceRemove {00B276CB-650D-4E84-8B8F-A005D4C06C7C} = s 'Fun Class'
   		{
   			ProgID = s 'ATLCOM.Fun.1'
   			VersionIndependentProgID = s 'ATLCOM.Fun'
   			InprocServer32 = s '%MODULE%'
   			{
   				val ThreadingModel = s 'Apartment'
   			}
   			'TypeLib' = s '{607C0BF2-5E09-42E7-A62F-407036FFAAD3}'
   		}
   	}
   }

    

   ATLCOM.idl文件中增加的内容：

   import "oaidl.idl";
   import "ocidl.idl";
   	[
   		object,
   		uuid(2EAC391A-5129-4EF8-BF2B-6E22DEC145DD),
   	
   		helpstring("IFun Interface"),
   		pointer_default(unique)
   	]
   	interface IFun : IUnknown
   	{
   	};
   
   [
   	uuid(607C0BF2-5E09-42E7-A62F-407036FFAAD3),
   	version(1.0),
   	helpstring("ATLCOM 1.0 Type Library")
   ]
   library ATLCOMLib
   {
   	importlib("stdole32.tlb");
   	importlib("stdole2.tlb");
   
   	[
   		uuid(00B276CB-650D-4E84-8B8F-A005D4C06C7C),
   		helpstring("Fun Class")
   	]
   	coclass Fun
   	{
   		[default] interface IFun;
   	};
   };

    

   ATLCOM.CPP增加的内容：
   

   BEGIN_OBJECT_MAP(ObjectMap)
   OBJECT_ENTRY(CLSID_Fun, CFun)
   END_OBJECT_MAP()
   

   编译后增加的文件：
   ATLCOM_p.c
   dlldata.c
   

　

添加接口函数

1. 操作步骤

   图五、调出增加接口方法的菜单 图六、增加接口函数 Add 图七、增加接口函数 Cat 　　请严格按照图六的方式，增加Add()函数；由于图七中增加Cat()函数的参数比较长，我没有适当的输入空格，请大家自己输入的时候注意一下。[in]表示参数方向是输入；[out]表示参数方向是输出；[out,retval]表示参数方向是输出，同时可以作为函数运算结果的返回值。一个函数中，可以有多个[in]、[out]，但[retval]只能有一个，并且要和[out]组合后在最后一个位置。(注5) 图八、接口函数定义完成后的图示 　　我们都知道，要想改变 C++ 中的类函数，需要修改两个地方：一是头文件(.h)中类的函数声明，二是函数体(.cpp)文件的实现处。而我们现在用 ATL 写组件程序，则还要修改一个地方，就是接口定义(IDL)文件。别着急 IDL 下次就要讨论啦。 　　由于 vc6.0 的BUG，导致大家在增加完接口和接口函数后，可能不会向上图（图八）所表现的样式。解决方法： 　 1 关闭工程，然后重新打开 该方法常常有效 2 关闭 IDE，然后重新运行   3 打开 IDL 文件，检查接口函数是否正确，如不正确请修改   4 打开 IDL 文件，随便修改一下(加一个空格，再删除这个空格)，然后保存 该方法常常有效 5 打开 h/cpp 文件，检查函数是否存在或是否正确，有则改之 无则嘉勉，不说完这个成语心理别扭 6 删除 IDL/H/CPP 中的接口函数，然后 再来一遍 7 重新建立工程、重新安装vc、重新安装windows、砸计算机 砸！

2. 增加内容
   
   ATLCOM.IDL文件
   

   // ATLCOM.idl : IDL source for ATLCOM.dll
   //
   
   // This file will be processed by the MIDL tool to
   // produce the type library (ATLCOM.tlb) and marshalling code.
   
   import "oaidl.idl";
   import "ocidl.idl";
   	[
   		object,
   		uuid(2EAC391A-5129-4EF8-BF2B-6E22DEC145DD),
   	
   		helpstring("IFun Interface"),
   		pointer_default(unique)
   	]
   	interface IFun : IUnknown
   	{
   		[helpstring("method Add")] HRESULT Add([in]long n1,[in]long n2,[out,retval]long*pval);
   	};
   
   [
   	uuid(607C0BF2-5E09-42E7-A62F-407036FFAAD3),
   	version(1.0),
   	helpstring("ATLCOM 1.0 Type Library")
   ]
   library ATLCOMLib
   {
   	importlib("stdole32.tlb");
   	importlib("stdole2.tlb");
   
   	[
   		uuid(00B276CB-650D-4E84-8B8F-A005D4C06C7C),
   		helpstring("Fun Class")
   	]
   	coclass Fun
   	{
   		[default] interface IFun;
   	};
   };
   

   Fun.h文件增加内容
   

   // Fun.h : Declaration of the CFun
   
   #ifndef __FUN_H_
   #define __FUN_H_
   
   #include "resource.h"       // main symbols
   
   /////////////////////////////////////////////////////////////////////////////
   // CFun
   class ATL_NO_VTABLE CFun : 
   	public CComObjectRootEx
          ,
   	public CComCoClass,
   	public IFun
   {
   public:
   	CFun()
   	{
   	}
   
   DECLARE_REGISTRY_RESOURCEID(IDR_FUN)
   
   DECLARE_PROTECT_FINAL_CONSTRUCT()
   
   BEGIN_COM_MAP(CFun)
   	COM_INTERFACE_ENTRY(IFun)
   END_COM_MAP()
   
   // IFun
   public:
            STDMETHOD(Add)(/*[in]*/long n1,/*[in]*/long n2,/*[out,retval]*/long*pval);
   };
   
   #endif //__FUN_H_
   

   Fun.cpp增加内容
   

   // Fun.cpp : Implementation of CFun
   #include "stdafx.h"
   #include "ATLCOM.h"
   #include "Fun.h"
   
   /////////////////////////////////////////////////////////////////////////////
   // CFun
   
   
   STDMETHODIMP CFun::Add(long n1, long n2, long *pval)
   {
         // TODO: Add your implementation code here
   
         return S_OK;
   }
   

 

其它文章索引

1. 字符串的处理，见 VC知识库第九期 《COM编程入门——第一部分》
2. 用ATL建立轻量级的COM对，见 VC 知识库第十三期