Com学习

最新推荐文章于 2024-03-18 08:25:58 发布
最新推荐文章于 2024-03-18 08:25:58 发布
阅读量1.4k 收藏 5
点赞数 3
分类专栏： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunshinewave/article/details/8303965
版权

 最近在学习COM，自己实现了一个小Demo，拿出来和大家分享一下。求各种批评。

我实现的这个组件向外提供了一个接口ICompTest,里面只有一个函数helloworld()，功能为返回一个整数89。

实现了自注册功能。下面贴出代码，希望对刚开始学习COM的朋友有所帮助。

 

首先看一下工程结构，编译环境为vs 2010

CompTest工程是服务端工程，是一个dll，CtrlTest是客户端工程，是一个控制台工程。

下面通过客户端的运行逻辑来讲述整个运行流程，先看一下CtrlTest.cpp文件

[cpp] view plain copy
  1. #include <iostream>  
  2. #include "ICompTest.h"  
  3.   
  4. using namespace std;  
  5.   
  6. int main()  
  7. {  
  8.     CoInitialize(NULL);     //初始化COM库，使用默认的内存分配器  
  9.     IUnknown* pUnknown = NULL;    
  10.     GUID CLSID_CompTestClass;  
  11.     HRESULT hResult = CLSIDFromProgID(L"COMCTL.CompTest", &CLSID_CompTestClass);    //获取ProgID为COMCTL.CompTest组建的CLSID  
  12.     if (S_OK != hResult){  
  13.         printf("Can't find CLSID!\n");  
  14.         return -1;  
  15.     }  
  16.     else{  
  17.         LPOLESTR szCLSID;     
  18.         StringFromCLSID(CLSID_CompTestClass, &szCLSID);     //将其转化为字符串形式用来输出  
  19.         wprintf(L"find CLSID \"%s\"\n",szCLSID);      
  20.         CoTaskMemFree(szCLSID);     //调用COM库的内存释放  
  21.     }  
  22.   
  23.     //用此CLSID创建一个COM对象并获取IUnknown接口  
  24.     hResult = CoCreateInstance(CLSID_CompTestClass, NULL, CLSCTX_INPROC_SERVER, IID_IUnknown,(void **)&pUnknown);  
  25.       
  26.     if (S_OK != hResult || NULL == pUnknown){  
  27.         printf("Create Object Failed!\n");  
  28.         return -1;  
  29.     }  
  30.   
  31.     ICompTest* pCompTest = NULL;  
  32.     hResult = pUnknown->QueryInterface(IID_ICompTest, (void**)&pCompTest);//通过此结构查询我们自己的ICompTest接口  
  33.   
  34.     cout << pCompTest->HelloWorld() << endl;//调用我们自己接口中的函数  
  35.     pCompTest->Release();    //释放自己的接口  
  36.     pUnknown->Release(); //释放IUnknown接口  
  37.     CoUninitialize();       //COM库反初始化  
  38.     return 0;  
  39. }  

这是客户程序的主逻辑，主要就是通过COM库创建CompTestClass对象，这个对象在这里是不可见的，这里只能拿到ICompTest接口，通过该接口调用函数HelloWorld。

下面看一下接口的声明ICompTest.h文件，这个文件是客户端和服务端都要有的。

[cpp] view plain copy
  1. #ifndef ICOMPTEST_H  
  2. #define ICOMPTEST_H  
  3.   
  4. #include <unknwn.h>  
  5.   
  6. // {81A80687-6CC4-4996-8DD2-F058907FDCA8}  
  7. static const GUID IID_ICompTest =   
  8. { 0x81a80687, 0x6cc4, 0x4996, { 0x8d, 0xd2, 0xf0, 0x58, 0x90, 0x7f, 0xdc, 0xa8 } };  
  9.   
  10.   
  11. class ICompTest :  
  12.     public IUnknown  
  13. {  
  14. public:  
  15.     virtual int _stdcall HelloWorld() = 0;  
  16. };  
  17. #endif  

这个文件中有一个GUID IID_ICompTest ，用于查询接口ICompTest 。

我们可以在 CtrlTest.cpp文件中看到CLSIDFromProgID和CoCreateInstance这两个函数，

第一个函数是要通过一个名字"COMCTL.CompTest"拿到一个CLSID，这个过程需要CLSID信息。

第二个函数是要通过这个CLSID找到我们的组件(dll)，并加载这个dll，然后创建COM对象，这个过程需要dll的路径信息。

这些信息都被放在注册表中，是这个组件自注册的时候由DllRegisterServer函数写入的。

我们可以先看一下注册之后注册表中的内容

其中COMCTL.CompTest是在键HKEY_CLASSES_ROOT下，{9CA9DBE8-C0B1-42c9-B6C7-856BE5756855}是在键HKEY_CLASSES_ROOT\CLSID下。

下面我们看一下这个dll的注册过程。

用“regsvr32.exe dll路径”对dll进行注册，实际上regsvr32只是调用了dll中的DllRegisterServer引出函数。

下面我们看一下DllRegisterServer函数的实现，这个函数在CompTest.cpp中。


  1. int myReg(LPCWSTR lpPath)   //将本组件的信息写入注册表,包括CLSID、所在路径lpPath、ProgID  
  2. {  
  3.     HKEY thk, tclsidk;  
  4.   
  5.     //打开键HKEY_CLASSES_ROOT\CLSID,创建新键为CompTestClass的CLSID，  
  6.     //在该键下创建键InprocServer32，并将本组件(dll)所在路径lpPath写为该键的默认值  
  7.     if (ERROR_SUCCESS == RegOpenKey(HKEY_CLASSES_ROOT, L"CLSID", &thk)){  
  8.         if (ERROR_SUCCESS == RegCreateKey(thk, L"{9CA9DBE8-C0B1-42c9-B6C7-856BE5756855}", &tclsidk)){  
  9.             HKEY tinps32k, tprogidk;  
  10.             if (ERROR_SUCCESS == RegCreateKey(tclsidk, L"InprocServer32", &tinps32k)){  
  11.                 if (ERROR_SUCCESS == RegSetValue(tinps32k, NULL, REG_SZ, lpPath, wcslen(lpPath) * 2)){  
  12.                 }  
  13.                 RegCloseKey(tinps32k);  
  14.             }  
  15.             RegCloseKey(tclsidk);  
  16.         }  
  17.         RegCloseKey(thk);  
  18.     }  
  19.     //在键HKEY_CLASSES_ROOT下创建新键为COMCTL.CompTest，  
  20.     //在该键下创建子键，并将CompTestClass的CLSID写为该键的默认值  
  21.     if (ERROR_SUCCESS == RegCreateKey(HKEY_CLASSES_ROOT, L"COMCTL.CompTest", &thk)){  
  22.         if (ERROR_SUCCESS == RegCreateKey(thk, L"CLSID", &tclsidk)){  
  23.             if (ERROR_SUCCESS == RegSetValue(tclsidk,   
  24.                 NULL,   
  25.                 REG_SZ,   
  26.                 L"{9CA9DBE8-C0B1-42c9-B6C7-856BE5756855}",  
  27.                 wcslen(L"{9CA9DBE8-C0B1-42c9-B6C7-856BE5756855}") * 2)){  
  28.             }  
  29.         }  
  30.     }  
  31.     //这样的话一个客户端程序如果想要使用本组件，首先可以以COMCTL.CompTest为参数调用CLSIDFromProgID函数  
  32.     //来获取CompTestClass的CLSID，再以这个CLSID为参数调用CoCreateInstance创建COM对象  
  33.     return 0;  
  34. }  
  35.   
  36. extern "C" HRESULT _stdcall DllRegisterServer()  
  37. {  
  38.     WCHAR szModule[1024];  
  39.     DWORD dwResult = GetModuleFileName(g_hModule, szModule, 1024); //获取本组件(dll)所在路径  
  40.     if (0 == dwResult){  
  41.         return -1;  
  42.     }  
  43.     MessageBox(NULL, szModule, L"", MB_OK);  
  44.     myReg(szModule);//将路径等信息写入注册表  
  45.     return 0;  
  46. }  


 

用“regsvr32.exe dll路径 -u”对dll进行反注册，同样，实际上regsvr32只是调用了dll中的DllUnregisterServer引出函数。

下面我们来看一下DllUnregisterServer函数的实现，这个函数在CompTest.cpp中。


  1. int myDelKey(HKEY hk, LPCWSTR lp)  
  2. {  
  3.     if (ERROR_SUCCESS == RegDeleteKey(hk, lp)){  
  4.     }  
  5.     return 0;  
  6. }  
  7.   
  8. int myDel() //删除注册时写入注册表的信息  
  9. {  
  10.     HKEY thk;  
  11.     if (ERROR_SUCCESS == RegOpenKey(HKEY_CLASSES_ROOT, L"CLSID", &thk)){  
  12.         myDelKey(thk, L"{9CA9DBE8-C0B1-42c9-B6C7-856BE5756855}\\InprocServer32");  
  13.         myDelKey(thk, L"{9CA9DBE8-C0B1-42c9-B6C7-856BE5756855}");  
  14.           
  15.         RegCloseKey(thk);  
  16.     }  
  17.     if (ERROR_SUCCESS == RegOpenKey(HKEY_CLASSES_ROOT, L"COMCTL.CompTest", &thk)){  
  18.         myDelKey(thk, L"CLSID");  
  19.     }  
  20.     myDelKey(HKEY_CLASSES_ROOT, L"COMCTL.CompTest");  
  21.     return 0;  
  22. }  
  23.   
  24. extern "C" HRESULT _stdcall DllUnregisterServer()  
  25. {  
  26.     myDel();//删除注册时写入注册表的信息  
  27.   
  28.     return 0;  
  29. }  

我们继续分析客户端的代码CoCreateInstance(CLSID_CompTestClass, NULL, CLSCTX_INPROC_SERVER, IID_IUnknown,(void **)&pUnknown);

这个函数是要调用CoGetClassObject函数，来获取CompTestClass的类厂，以此创建CompTestClass对象并获取IUnknown接口。其中，CoGetClassObject函数

实际上是调用了CompTest.cpp中的又一个引出函数DllGetClassObject来获取IClassFactory接口的。最终CoCreateInstance会调用IClassFactory接口的CreateInstance

函数去创建COM对象。

下面我们看一下DllGetClassObject函数的实现

  1. extern "C" HRESULT _stdcall DllGetClassObject(__in REFCLSID rclsid, __in REFIID riid, LPVOID FAR* ppv)//用于创建类厂并返回所需接口，由CoGetClassObject函数调用  
  2. {  
  3.     if (CLSID_CompTestClass == rclsid){  
  4.         CompTestFactory* pFactory = new CompTestFactory();//创建类厂对象  
  5.         if (NULL == pFactory){  
  6.             return E_OUTOFMEMORY;  
  7.         }  
  8.         HRESULT result = pFactory->QueryInterface(riid, ppv);//获取所需接口  
  9.         return result;  
  10.     }  
  11.     else{  
  12.         return CLASS_E_CLASSNOTAVAILABLE;  
  13.     }  
  14. }  

接下来我们看一下组件中的最后一个引出函数DllCanUnloadNow，这样dll中的所有引出函数就都出现了

  1. extern "C" HRESULT _stdcall DllCanUnloadNow()//用于判断是否可以卸载本组建, 由CoFreeUnusedLibraries函数调用  
  2. {  
  3.     if (0 == g_num){//如果对象个数为0，则可以卸载  
  4.         return S_OK;  
  5.     }  
  6.     else{  
  7.         return S_FALSE;  
  8.     }  
  9. }  
其中ULONG g_num表示组件中CompTestClass对象的个数,用于判断是否可以卸载本组建，如值为0则可以卸载

下面我们看一下CompTest.cpp的全貌


  1. #include <iostream>  
  2. #include <windows.h>  
  3.   
  4. #include "factory.h"  
  5. #include "CompTestClass.h"  
  6.   
  7. using namespace std;  
  8.   
  9. HMODULE g_hModule;  //dll进程实例句柄  
  10. ULONG g_num;        //组件中CompTestClass对象的个数,用于判断是否可以卸载本组建，如值为0则可以卸载  
  11.   
  12. int myReg(LPCWSTR lpPath)   //将本组件的信息写入注册表,包括CLSID、所在路径lpPath、ProgID  
  13. {  
  14.     HKEY thk, tclsidk;  
  15.   
  16.     //打开键HKEY_CLASSES_ROOT\CLSID,创建新键为CompTestClass的CLSID，  
  17.     //在该键下创建键InprocServer32，并将本组件(dll)所在路径lpPath写为该键的默认值  
  18.     if (ERROR_SUCCESS == RegOpenKey(HKEY_CLASSES_ROOT, L"CLSID", &thk)){  
  19.         if (ERROR_SUCCESS == RegCreateKey(thk, L"{9CA9DBE8-C0B1-42c9-B6C7-856BE5756855}", &tclsidk)){  
  20.             HKEY tinps32k, tprogidk;  
  21.             if (ERROR_SUCCESS == RegCreateKey(tclsidk, L"InprocServer32", &tinps32k)){  
  22.                 if (ERROR_SUCCESS == RegSetValue(tinps32k, NULL, REG_SZ, lpPath, wcslen(lpPath) * 2)){  
  23.                 }  
  24.                 RegCloseKey(tinps32k);  
  25.             }  
  26.             RegCloseKey(tclsidk);  
  27.         }  
  28.         RegCloseKey(thk);  
  29.     }  
  30.     //在键HKEY_CLASSES_ROOT下创建新键为COMCTL.CompTest，  
  31.     //在该键下创建子键，并将CompTestClass的CLSID写为该键的默认值  
  32.     if (ERROR_SUCCESS == RegCreateKey(HKEY_CLASSES_ROOT, L"COMCTL.CompTest", &thk)){  
  33.         if (ERROR_SUCCESS == RegCreateKey(thk, L"CLSID", &tclsidk)){  
  34.             if (ERROR_SUCCESS == RegSetValue(tclsidk,   
  35.                 NULL,   
  36.                 REG_SZ,   
  37.                 L"{9CA9DBE8-C0B1-42c9-B6C7-856BE5756855}",  
  38.                 wcslen(L"{9CA9DBE8-C0B1-42c9-B6C7-856BE5756855}") * 2)){  
  39.             }  
  40.         }  
  41.     }  
  42.     //这样的话一个客户端程序如果想要使用本组件，首先可以以COMCTL.CompTest为参数调用CLSIDFromProgID函数  
  43.     //来获取CompTestClass的CLSID，再以这个CLSID为参数调用CoCreateInstance创建COM对象  
  44.     return 0;  
  45. }  
  46.   
  47. extern "C" HRESULT _stdcall DllRegisterServer()  
  48. {  
  49.     WCHAR szModule[1024];  
  50.     DWORD dwResult = GetModuleFileName(g_hModule, szModule, 1024); //获取本组件(dll)所在路径  
  51.     if (0 == dwResult){  
  52.         return -1;  
  53.     }  
  54.     MessageBox(NULL, szModule, L"", MB_OK);  
  55.     myReg(szModule);//将路径等信息写入注册表  
  56.     return 0;  
  57. }  
  58.   
  59. int myDelKey(HKEY hk, LPCWSTR lp)  
  60. {  
  61.     if (ERROR_SUCCESS == RegDeleteKey(hk, lp)){  
  62.     }  
  63.     return 0;  
  64. }  
  65.   
  66. int myDel() //删除注册时写入注册表的信息  
  67. {  
  68.     HKEY thk;  
  69.     if (ERROR_SUCCESS == RegOpenKey(HKEY_CLASSES_ROOT, L"CLSID", &thk)){  
  70.         myDelKey(thk, L"{9CA9DBE8-C0B1-42c9-B6C7-856BE5756855}\\InprocServer32");  
  71.         myDelKey(thk, L"{9CA9DBE8-C0B1-42c9-B6C7-856BE5756855}");  
  72.           
  73.         RegCloseKey(thk);  
  74.     }  
  75.     if (ERROR_SUCCESS == RegOpenKey(HKEY_CLASSES_ROOT, L"COMCTL.CompTest", &thk)){  
  76.         myDelKey(thk, L"CLSID");  
  77.     }  
  78.     myDelKey(HKEY_CLASSES_ROOT, L"COMCTL.CompTest");  
  79.     return 0;  
  80. }  
  81.   
  82. extern "C" HRESULT _stdcall DllUnregisterServer()  
  83. {  
  84.     myDel();//删除注册时写入注册表的信息  
  85.   
  86.     return 0;  
  87. }  
  88.   
  89. extern "C" HRESULT _stdcall DllCanUnloadNow()//用于判断是否可以卸载本组建, 由CoFreeUnusedLibraries函数调用  
  90. {  
  91.     if (0 == g_num){//如果对象个数为0，则可以卸载  
  92.         return S_OK;  
  93.     }  
  94.     else{  
  95.         return S_FALSE;  
  96.     }  
  97. }  
  98.   
  99. extern "C" HRESULT _stdcall DllGetClassObject(__in REFCLSID rclsid, __in REFIID riid, LPVOID FAR* ppv)//用于创建类厂并返回所需接口，由CoGetClassObject函数调用  
  100. {  
  101.     if (CLSID_CompTestClass == rclsid){  
  102.         CompTestFactory* pFactory = new CompTestFactory();//创建类厂对象  
  103.         if (NULL == pFactory){  
  104.             return E_OUTOFMEMORY;  
  105.         }  
  106.         HRESULT result = pFactory->QueryInterface(riid, ppv);//获取所需接口  
  107.         return result;  
  108.     }  
  109.     else{  
  110.         return CLASS_E_CLASSNOTAVAILABLE;  
  111.     }  
  112. }  
  113.   
  114.   
  115. BOOL APIENTRY DllMain( HMODULE hModule,  
  116.                        DWORD  ul_reason_for_call,  
  117.                        LPVOID lpReserved  
  118.                      )  
  119. {  
  120.     g_hModule = hModule;//获取进程实例句柄，用于获取本组件(dll)路径  
  121.     switch (ul_reason_for_call)  
  122.     {  
  123.     case DLL_PROCESS_ATTACH:  
  124.     case DLL_THREAD_ATTACH:  
  125.     case DLL_THREAD_DETACH:  
  126.     case DLL_PROCESS_DETACH:  
  127.         break;  
  128.     }  
  129.     return TRUE;  
  130. }  


 

下面是.def文件mydef.def用于声明dll的引出函数


  1. LIBRARY "CompTest"  
  2. EXPORTS  
  3. DllCanUnloadNow  
  4. DllGetClassObject  
  5. DllUnregisterServer  
  6. DllRegisterServer  

 

下面是剩下的文件，有些许注释，语焉不详之处，望海涵。

CompTestClass.h

  1. #ifndef COMPTESTCLASS_H  
  2. #define COMPTESTCLASS_H  
  3.   
  4.   
  5. #include "ICompTest.h"  
  6.   
  7. // {9CA9DBE8-C0B1-42c9-B6C7-856BE5756855}  
  8. static const GUID CLSID_CompTestClass =   
  9. { 0x9ca9dbe8, 0xc0b1, 0x42c9, { 0xb6, 0xc7, 0x85, 0x6b, 0xe5, 0x75, 0x68, 0x55 } };  
  10.   
  11. class CompTestClass :  
  12.     public ICompTest  
  13. {  
  14. public:  
  15.       
  16.     CompTestClass();  
  17.     ~CompTestClass();  
  18.   
  19.     //要实现IUnknown接口  
  20.     virtual HRESULT _stdcall QueryInterface(const IID& riid, void** ppvObject);  
  21.     virtual ULONG _stdcall AddRef();  
  22.     virtual ULONG _stdcall Release();  
  23.   
  24.     //要实现ICompTest接口  
  25.     virtual int _stdcall HelloWorld();  
  26. protected:  
  27.   
  28.     ULONG m_Ref;  
  29. };  
  30. #endif  


CompTestClass.cpp

  1. /** 
  2. *  @file CompTestClass.cpp 
  3. *  @author LiWang112358 
  4. *  @date 2012/3/17 
  5. *  @version 1.0 
  6. *  @brief CompTestClass类的实现 
  7. */  
  8. #include "CompTestClass.h"  
  9.   
  10. ULONG CompTestClass::m_objNum = 0;//组件中CompTestClass对象的个数,用于判断是否可以卸载本组建，如值为0则可以卸载  
  11. CRITICAL_SECTION CompTestClass::m_cs;//为了多线程调用对m_objNum加的锁  
  12.   
  13. CompTestClass::CompTestClass()  
  14. {  
  15.     m_Ref = 0;  
  16.     autoLock tlock(m_cs);  
  17.     m_objNum ++;    //构造了一个对象  
  18. }  
  19.   
  20. CompTestClass::~CompTestClass()  
  21. {  
  22.     autoLock tlock(m_cs);  
  23.     m_objNum --;    //释放了一个对象  
  24. }  
  25.   
  26. HRESULT _stdcall CompTestClass::QueryInterface(const IID &riid, void **ppvObject)  
  27. {  
  28.     if (IID_IUnknown == riid){  
  29.         *ppvObject = (IUnknown*)this;  
  30.         ((IUnknown*)(*ppvObject))->AddRef();  
  31.     }  
  32.     else if (IID_ICompTest == riid){  
  33.         *ppvObject = (ICompTest*)this;  
  34.         ((ICompTest*)(*ppvObject))->AddRef();  
  35.     }  
  36.     else{  
  37.         *ppvObject = NULL;  
  38.         return E_NOINTERFACE;  
  39.     }  
  40.     return S_OK;  
  41. }  
  42.   
  43. ULONG _stdcall CompTestClass::AddRef()  
  44. {  
  45.     m_Ref ++;  
  46.     return m_Ref;  
  47. }  
  48.   
  49. ULONG _stdcall CompTestClass::Release()  
  50. {  
  51.     m_Ref --;  
  52.     if (0 == m_Ref){  
  53.         delete this;  
  54.         return 0;  
  55.     }  
  56.     return m_Ref;  
  57. }  
  58.   
  59. int _stdcall CompTestClass::HelloWorld()//ICompTest接口的实现，返回一个整数89  
  60. {  
  61.     return 89;  
  62. }  
  63.   
  64. int CompTestClass::Init()  
  65. {  
  66.     m_objNum = 0;  
  67.     InitializeCriticalSection(&m_cs);  
  68.     return 0;  
  69. }  
  70.   
  71. ULONG CompTestClass::ObjNum()  
  72. {  
  73.     return m_objNum;  
  74. }  

 

factory.h


  1. #ifndef FACTORY_H  
  2. #define FACTORY_H  
  3.   
  4. #include <unknwn.h>  
  5.   
  6.   
  7. class CompTestFactory :  
  8.     public IClassFactory  
  9. {  
  10. public:  
  11.     CompTestFactory();  
  12.     ~CompTestFactory();  
  13.   
  14.     //要实现IUnknown接口  
  15.     virtual HRESULT _stdcall QueryInterface(const IID& riid, void** ppvObject);  
  16.     virtual ULONG _stdcall AddRef();  
  17.     virtual ULONG _stdcall Release();  
  18.   
  19.     //要实现IClassFactory接口  
  20.     virtual HRESULT _stdcall CreateInstance(IUnknown *pUnkOuter, const IID& riid, void **ppvObject);  
  21.     virtual HRESULT _stdcall LockServer(BOOL fLock);  
  22.   
  23. protected:  
  24.     ULONG m_Ref;  
  25. };  
  26.   
  27. #endif  

 

factory.cpp

  1.   
  2. #include "factory.h"  
  3. #include "CompTestClass.h"  
  4.   
  5. CompTestFactory::CompTestFactory()  
  6. {  
  7.     m_Ref = 0;  
  8. }  
  9.   
  10. CompTestFactory::~CompTestFactory()  
  11. {  
  12.   
  13. }  
  14.   
  15. HRESULT _stdcall CompTestFactory::QueryInterface(const IID &riid, void **ppvObject)  
  16. {  
  17.     if (IID_IUnknown == riid){  
  18.         *ppvObject = (IUnknown*)this;  
  19.         ((IUnknown*)(*ppvObject))->AddRef();  
  20.     }  
  21.     else if (IID_IClassFactory == riid){  
  22.         *ppvObject = (IClassFactory*)this;  
  23.         ((IClassFactory*)(*ppvObject))->AddRef();  
  24.     }  
  25.     else{  
  26.         *ppvObject = NULL;  
  27.         return E_NOINTERFACE;  
  28.     }  
  29.     return S_OK;  
  30. }  
  31.   
  32. ULONG _stdcall CompTestFactory::AddRef()  
  33. {  
  34.     m_Ref ++;  
  35.     return m_Ref;  
  36. }  
  37.   
  38. ULONG _stdcall CompTestFactory::Release()  
  39. {  
  40.     m_Ref --;  
  41.     if (0 == m_Ref){  
  42.         delete this;  
  43.         return 0;  
  44.     }  
  45.     return m_Ref;  
  46. }  
  47.   
  48. HRESULT _stdcall CompTestFactory::CreateInstance(IUnknown *pUnkOuter, const IID &riid, void **ppvObject)//最重要的函数，这个函数创建CompTestClass对象，并返回所需接口  
  49. {  
  50.     if (NULL != pUnkOuter){  
  51.         return CLASS_E_NOAGGREGATION;  
  52.     }  
  53.     HRESULT hr = E_OUTOFMEMORY;  
  54.     CompTestClass::Init();  
  55.     CompTestClass* pObj = new CompTestClass();   
  56.     if (NULL == pObj){  
  57.         return hr;  
  58.     }  
  59.   
  60.     hr = pObj->QueryInterface(riid, ppvObject);  
  61.     if (S_OK != hr){  
  62.         delete pObj;  
  63.     }  
  64.     return hr;  
  65. }  
  66.   
  67. HRESULT _stdcall CompTestFactory::LockServer(BOOL fLock)  
  68. {  
  69.     return NOERROR;  
  70. }  


以下是客户程序的运行结果

深度学习知识点全面总结
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
01-05 27万+
本文详细介绍深度学习概念及原理，参考网上相关资料汇总，内容包含众多章节，包括神经网络基础及常见深度学习网络结构介绍，用于个人学习总结，适合深度学习初学者学习。同时介绍机器学习常见的分类算法：SVM、神经网络、随机森林、逻辑回归、KNN、贝叶斯。常见的监督学习算法：感知机、SVM、人工神经网络、决策树、逻辑回归.........
深度学习系列资料总结
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
07-17 2万+
说明本系列深度学习资料集合包含机器学习、深度学习等各系列教程，主要以计算机视觉资料为主，包括图像识别、分类、检测、分割等，内容参考Github及网络资源，仅供个人学习。深度学习定义一般是指通过训练多层网络结构对未知数据进行分类或回归深度学习分类有监督学习方法——深度前馈网络、卷积神经网络、循环神经网络等；无监督学习方法——深度信念网、深度玻尔兹曼机，深度自编码器等。手写机器学习笔记github机器学习算法公式推导以及numpy实现github人工智能相关术语link。..................
用C++编写的一个基本的Com组件
07-04
最近在学Com，程序是参考COM技术内幕和其它一些书籍编写的，其中编写COM在ComImplementation里，以及一个测试程序在ComTest里。请注意：如果是在Win7下编程，注册组件的dll时，必须要：开始-所有程序-附件-命令提示符，注意要右击，以管理员身份运行，否则不能成功注册。
用纯粹的C++编写COM组件
蝈蝈俊.net
04-25 2659
赵湘宁下载本文代码    本文提供一个完全用C++实现的进程内（DLL）COM服务器，不要ATL或MFC提供任何支持。用这种方式编写COM对象可以让你深入地洞察到COM处理进程内服务器的方法以及COM是如何创建类工厂的。利用本文提供的这个简单框架你可以实现很基本的COM组件，如外壳扩展（Shell Extensions）等。如果你在使用过程中发现了任何问题，请将它反馈到vckbase@public
C++ COM组件的编写
千里之外
03-27 2万+
COM组件的编写         本文提供一个完全用C++实现的进程内（DLL）COM服务器，不要ATL或MFC提供任何支持。用这种方式编写COM对象可以让你深入地洞察到COM处 理进程内服务器的方法以及COM是如何创建类工厂的。利用本文提供的这个简单框架你可以实现很基本的COM组件，如外壳扩展（Shell Extensions）等。如果你在使用过程中发现了任何问题，请将它反馈到vckb
COM - 给 C++ 程序员的 COM 入门指南
0011411的专栏
04-27 2135
虽然 COM 中对象和接口的区别与 C++ 中的含义不同，但我可能会在不引起混淆的情况下混用这两者。此外，我对 COM 的版本不做区分，也就是说，我用 COM 来称呼 COM，DCOM（Distributed COM） 和 COM+（从 Windows 2000 开始支持的 COM 的一个改进版本）。）1. 二进制对象标准a. C++ 的对象布局大家都知道，在 C++ 里面
C++ COM
u012463389的博客
04-01 1027
前言:为了介绍C#写界面，C++写算法的快捷交互开发方式，首先介绍c++，C#内部的DLL，COM调用。 一，COM COM (Component Object Model),微软为提高代码的可从用性而开发的组件对象模型的软件架构，在windows系统的开发中大量的使用了这种技术，使用这种技术我们尽可能的把我们的软件划分位许多组件，通过组件的组合调用最总实现软件的目的，COM的使用不仅大大
机器学习和深度学习的区别
虚幻私塾
01-11 6万+
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 终于考上人工智能的研究僧啦，不知道机器学习和深度学习有啥区别，感觉一切都是深度学习 挖槽，听说学长已经调了10个月的参数准备发有2000亿参数的T9开天霹雳模型，我要调参发T10准备拿个Best Paper 现在搞传统机器学习相关的研究论文确实占比不太高，有的人吐槽深度学
PyTorch深度学习实战（39）——小样本学习(Few-shot Learning)
最新发布
盼小辉丶的博客
03-18 4254
小样本学习 (Few-shot Learning) 旨在解决在训练集中只有很少样本的情况下进行分类和推理的问题。在小样本学习中，我们希望通过利用已有的少量样本和先验知识来进行泛化，以便在面对新的、未见过的类别时能够做出准确的预测。这就要求模型能够从有限的训练样本中提取出有用的信息，并能够将这些信息应用到新类别的样本中去。在本节中，将介绍孪生、原型和关系网络的原理，并使用 PyTorch 实现孪生网络。
李宏毅2020机器学习资料汇总
热门推荐
⚡
04-08 8万+
前言 可能受到新冠病毒的影响，台大也开始了网课教学。李宏毅上传了2020版本的机器学习视频，可以说是非常好的学习资料（尽管其中多数都是2017、2019的视频，但有部分更新）。 和吴恩达的CS229机器学习相比，中文版本的机器学习显得亲民了许多，李宏毅的机器学习是英文的ppt+中文讲解，非常有利于大家入门。吴恩达的CS229中偏向于传统机器学习……
c++实现最简单的COM
06-16
实现一个最简单的COM组件，麻雀虽小，五脏俱全，使用完全C++和COM库实现，可以看到整个COM组件的组成脉络。
c++调用com的方法
05-12
使用vs2008简单编写了一个com组件dll,后用vs2008分别用4中方法进行调用，方法详解在http://blog.csdn.net/angellove156/article/details/25633421
纯C++建立的COM组件demo
08-24
自己写的，一个进程内COM组件的例子，很简陋，但是能说明基本结构了
在VS环境下使用C++编写你的第一个COM
qq_51170743的博客
02-17 1002
在VS(2022)环境下使用C++编写你的第一个COM
关于C++编写com和调用com组件的小例子以及个人所犯错误见解
qwezhaohaihong
04-23 3057
最近在完成研究生课程面向对象方法的第一次作业编写一个com： 环境Visual Studio 2015 一、构造COM组件，项目名称为ComZhh，过程 进入VS，选择左上角的文件，点击新建项目->VisualC++->ATL->ATL项目 注意在下一步中勾选支持com+1.0 接着你讲看到项目下有两个目录 不要着急，你只需要关注ATLProject1即...
使用纯粹的C++语言编写COM组件
az44yao的专栏
06-11 665
http://www.yesky.com/412/1803412_2.shtml
vs、c++环境下开发使用com组件
baidu_16370559的博客
07-06 5506
COM组件是一组接口的集合，由Win32动态链接库（DLL）或可执行文件（EXE）的形式发布的可执行二进制代码组成。com是独立于语言的组件体系结构，可以用C++、Java和VB等任意一种语言编写com对象。COM组件的优点有：通过接口对功能分类；功能扩充，只需添加接口就行；可轻松实现进程间调用、分布式调用；具有封装、继承、多态的面向对象特征。COM是规范，以该规范实现的DLL可视为COM组件。
c++ 实现 com
max2009verygood的专栏
08-21 456
// ImpLock.h : CImpLock 的声明 #pragma once #include "resource.h" // 主符号 #include "MeromLock_i.h" #if defined(_WIN32_WCE) &amp;&amp; !defined(_CE_DCOM) &amp;&amp; !defined(_CE_ALLOW_SINGLE_...
用C++编写COM组件
dingtaocpp的园子
09-01 3149
http://www.yesky.com/dev/382/2019882.shtml                                                                                           COM组件的编写         本文提供一个完全用C++实现的进程内（DLL）COM服务器，不要ATL或MFC提供任何支持
AUTOSAR COM学习
10-03
AUTOSAR的COM模块主要用于处理信号的接收和发送事宜。它的传输特性是一进一出，有来有回的方式。在AUTOSAR方法论中，所有输入输出文件都是ARXML文件类型，包括与DBC文件和LDF文件起到相同作用的文件。当使用AUTOSAR工具导入DBC/LDF文件时，会根据规则进行转换。因此，AUTOSAR COM学习的关键是了解COM模块的信号处理机制和ARXML文件的使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值