总结下C++中模块(Dll)对外暴露接口的方式

总结下C++中模块(Dll)对外暴露接口的方式：

(1)导出API函数的方式

​ 这种方式是Windows中调用DLL接口的最基本方式，GDI32.dll, User32.dll都是用这种方式对外暴露系统API的。

优点：

​ 导出函数没有语言限制，什么语言都能调用；

缺点：

​ 这种方式是面向过程的，外部如果要支持多实例等不是很方便，另外它要求的回调函数(callback)只能是普通C函数，C++中我们通常用类静态成员函数，很不方便。

​ 当然，我们通过封装其实也可以让这种方式支持多实例。

​ 通过一个抽象句柄HComponent， 比如:

​ 1.支持导出函数HComponent CreateInstance(); VOID DeleteInstance(HComponent h);

​ 2.然后内部的其他导出函数的第一个参数都是实例句柄，类似INT SendMessage(HComponent h, …)， 用这种方式可以模拟出面向对象的效果。

​ 另外如果用动态加载(LoadLibrary, GetProcAddress)的方式调用它的导出函数，即使导出函数内部实现修改了，外部程序也不用重新编译，仍然可用。

​ 导出函数方式一个比较优秀的例子是GDI+的实现，整个GdiPlus.dll对外提供的都是普通导出函数，但是它却可以方便的给面向对象的语言使用，因为一方面它用Handle的方式在DLL内部封装了对象，另一方面它在DLL外围又用C++类的方式封装了头文件直接提供给用户， 所以C++程序可以直接以面向对象的方式调用。

(2)导出类方式

导出类的方式就是把整个C++类对外导出, MFC42.dll就是这种方式。

优点

​ 直接面向对象。

缺点

​ 只能给C++用，而且最好编译器都要一致，另外DLL一变动， 外部程序需要重新编译， 而且外部程序可以通过头文件看到你类的内部实现，所以这种方式是最不建议使用的方式。

(3)COM方式

COM方式实际上导出了几个固定函数(DllGetClassObject, DllCanUnloadNow, DllRegisterServer, DllUnregisterServer), 然后以这几个函数为入口，调用组件内部实现的接口。

优点：

​ COM方式综合了上面2种方法的所有优点，没有语言限制，面向对象，多实例，只能看到接口，动态升级等。

缺点：

​ 较复杂和对注册表的依赖

​ 当然COM因为其复杂性和对注册表的依赖，很多时候我们在封装模块时不愿意严格按照COM标准来实现，但是我们可以按照COM思想来提供接口。
​ 比如我们可以让我们模块只提供一个导出函数CreateFactory, 然后外部可以调用该接口来创建工厂，最后通过工厂创建出各种类型的对象，这些对象实现了某些接口，外部只需要这些接口的头文件即可调用对象的方法。
​ 现在越来越多的组件以这种方式对外提供接口，比如D2D对外的导出接口就是D2D1CreateFactory， 然后就可以通过该工厂来创建其他的对象，比如pD2DFactory->CreateHwndRenderTarget(…)，最后可以直接调用对象实现的接口：pRenderTarget->DrawRectangle(D2D1::RectF(100.f, 100.f, 500.f, 500.f), pBlackBrush);

​ 当然，上面几种DLL对外暴露接口的方式本质上没有区别，都是利用PE文件的导出节来导出数据和函数，但是根据它们使用方式的不同，对外部模块来说还是有很大的区别，推荐次序依次是:COM方式->导出API函数方式->导出类方式。

深入CoCreateInstance()：

  1. 客户端程序调用CoCreateInstance()，传递组件对象类的CLSID以及所要接口的IID。
  2. COM库在HKEY_CLASSES_ROOT\CLSID.键值下查找服务器的CLSID键值，这个键值包含服务器的注册信息。
  3. COM库读取服务器DLL的全路径并将DLL加载到客户端的进程空间。
  4. COM库调用在服务器中DllGetClassObject()函数为所请求的组件对象类请求类工厂。
  5. 服务器创建一个类工厂并将它从DllGetClassObject()返回。
  6. COM库在类工厂中调用CreateInstance()方法创建客户端程序请求的COM对象。
  7. CreateInstance()返回一个接口指针到客户端程序。

步骤

1.创建一个COM接口

.h文件：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
typedef  struct  Interface

Interface ISimpleMsgBox : public IUnknown//COM定义的每一个接口都必须从IUnknown继承过来
{
    //IUnknown
    STDMETHOD_(ULONG, AddRef)() PURE;
    STDMETHOD_(ULONG, Release)() PURE;
    STDMETHOD(QueryInterface)(REFIID riid, void** ppv) PURE;
 	//STDMETHOD()包含virtual关键字，返回类型和调用规范,PURE扩展了C++的“=0”，使此函数成为一个纯虚拟函数。STDMETHOD_()也一样，除非你指定不同的返回类型。*
    
  	//ISimpleMsgBox
    STDMETHOD(DoSimpleMsgBox)(HWND hwndParent, BSTR bsMessageText) PURE;
};
struct __declspec(uuid("{7D51904D-1645-4a8c-BDE0-0F4A44FC38C4}")) ISimpleMsgBox;

​ COM定义的每一个接口都必须从IUnknown继承过来，其原因在于IUnknown接口提供了两个非常重要的特性：生存期控制和接口查询。客户程序只能通过接口与COM对象进行通信，虽然客户程序可以不管对象内部的实现细节，但它要控制对象的存在与否。计算机与计算机或计算机与终端之间的数据传送可以采用串行通讯和并行通讯二种方式。

若不采用上述方式创建一个接口，而是使用idl文件定义接口的话，虽然会生成相关头文件,但可读性很差

2.声明一个C++类来实现该接口

.h文件：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
extern UINT g_uDllRefCount;  // 服务器的引用计数

HRESULT DllCanUnloadNow()
{
    return (g_uDllRefCount > 0) ? S_FALSE : S_OK;
}
class CSimpleMsgBoxImpl : public ISimpleMsgBox//该类继承COM类接口  
{
	public:
		CSimpleMsgBoxImpl();
		virtual ~CSimpleMsgBoxImpl();
 
    	//父类中是纯虚函数，子类进行具体的定义
 		//IUnknown
 		STDMETHOD_(ULONG, AddRef)();
 		STDMETHOD_(ULONG, Release)();
 		STDMETHOD(QueryInterface)(REFIID riid, void** ppv);
 		
 		//ISimpleMsgBox
 		STDMETHOD(DoSimpleMsgBox)(HWND hwndParent, BSTR bsMessageText);

	protected:
		ULONG m_uRefCount;//对象的引用计数
};
class  __declspec(uuid("{7D51904E-1645-4a8c-BDE0-0F4A44FC38C4}")) CSimpleMsgBoxImpl;

重点关注QueryInterface和DoSimpleMsgBox部分

.c文件：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
//构造器和析构器管理服务器的引用计数：
CSimpleMsgBoxImpl::CSimpleMsgBoxImpl()
{
    m_uRefCount = 0;
    g_uDllRefCount++;
}
CSimpleMsgBoxImpl::~CSimpleMsgBoxImpl()
{
    g_uDllRefCount--;
}

ULONG CSimpleMsgBoxImpl::AddRef()
{
    return ++m_uRefCount;
}

//注意Release()的实现假设COM对象在堆中创建。如果在全局粘上创建某个对象，当对象试图删除自己时就会出问题。
ULONG CSimpleMsgBoxImpl::Release()
{
   ULONG uRet = --m_uRefCount;
   if ( 0 == m_uRefCount )  // 是否释放了最后的引用?
       delete this;
　　return uRet;
}

//QueryInterface()简称QI()，由客户端程序调用这个函数从COM对象请求不同的接口。在本例中因为只实现一个接口，QI()会很容易使用。QI()有两个参数：一个是所请求的接口IID，一个是指针的缓冲大小，如果查询成功，QI()将接口指针地址存储在这个缓冲指针中。
STDMETHODIMP CSimpleMsgBoxImpl::QueryInterface ( REFIID riid, void** ppv )
{
	HRESULT hrRet = S_OK;//先将hrRet置为True
	TRACE(">>> SimpleMsgBoxSvr: In CSimpleMsgBoxImpl::QueryInterface()\n" );
    
    //是否判断调用进程是否拥有对指定地址段内存的写操作权限
    //返回BOOL值，表示当前进程是否拥有ppv指针指向的字符串的写入权限。
    if ( IsBadWritePtr ( ppv, sizeof(void*) ))
        return E_POINTER;
        
    //标准QueryInterface()初始化，将*ppv置为NULL。
    *ppv = NULL;
    //如果客户端请求我们支持的接口，给*ppv赋值
    if ( InlineIsEqualGUID ( riid, IID_IUnknown ))
    {
        *ppv = (IUnknown*) this;//强制类型转换
        TRACE(">>> SimpleMsgBoxSvr: Client QIed for IUnknown\n" );
    }
    else if ( InlineIsEqualGUID ( riid, __uuidof(ISimpleMsgBox) ))
	{
		*ppv = (ISimpleMsgBox*) this;//强制类型转换
        TRACE(">>> SimpleMsgBoxSvr: Client QIed for ISimpleMsgBox\n" );
    }
	else//提供客户端请求的接口：没有接口，com组件的版本太低了或根本就没有，不含有高版本的接口。
	{
        hrRet = E_NOINTERFACE;  //将hrRet置为False
        TRACE(">>> SimpleMsgBoxSvr: Client QIed for unsupported interface\n" );
    }
	//如果返回一个接口指针。则调用AddRef()增加引用计数.
    if ( S_OK == hrRet )
    {
        ((IUnknown*) *ppv)->AddRef();//计数+1
    }
    return hrRet;
}

//ISimpleMsgBox的相关方法：DoSimpleMsgBox实现
STDMETHODIMP CSimpleMsgBoxImpl::DoSimpleMsgBox ( HWND hwndParent, BSTR bsMessageText )
{
	_bstr_t bsMsg = bsMessageText;
	LPCTSTR szMsg = (TCHAR*) bsMsg;//必要时使用_bstr_t将字符串转换为ANSI。
    //LPCTSTR用来表示你的字符是否使用UNICODE编码, 如果你的程序定义了UNICODE或者其他相关的宏，那么这个字符或者字符串将被作为UNICODE字符串，否则就是标准的ANSI字符串。
	
    TRACE(">>> SimpleMsgBoxSvr: In CSimpleMsgBoxImpl::DoSimpleMsgBox()\n" );
    MessageBox ( hwndParent, szMsg, _T("Simple Message Box"), MB_OK );//提示框
    return S_OK;
}

在QueryInterface()中做了三件不同的事情：

  • 初始化传入的指针为NULL[*ppv = NULL;]。
  • 检查riid，确定组件对象类(coclass)实现了客户端所请求接口.[if ( InlineIsEqualGUID( riid, IID_IUnknown ))]
  • 如果确实实现勒索请求的接口，则增加COM对象的引用计数。[((IUnknown) *ppv)->AddRef();]AddRef()调用很关键。*ppv = (IUnknown) this;

​ 要创建新的COM对象引用，就必须调用这个函数通知COM对象这个新引用成立。在AddRef()调用中的强制转换IUnknown看起来好像多余，但是在QI()中初始化的\ppv有可能不是IUnknown*类型，所以最好是养成习惯对之进行强行转换。

​ COM服务器必须在Windows注册表中正确注册以后才能正常工作。如果你看一下注册表中的HKEY_CLASSES_ROOT\CLSID键，就会发现大把大把子键，它们就是在这个计算机上注册的COM服务器。当某个COM服务器注册后（通常是用DllRegisterServer()进行注册），就会以标准的注册表格式在CLSID键下创建一个键，它名字为服务器的GUID。

​ 下面是一个这样的例子：

​ {067DF822-EAB6-11cf-B56E-00A0244D5087}

​ 注：大括弧和连字符是必不可少的，字母大小写均可。

3.为接口和类指定各自指定一个GUID

使用VC++扩展方法

下面两个在上面的.h文件中定义

1
2
struct __declspec(uuid("{7D51904D-1645-4a8c-BDE0-0F4A44FC38C4}")) ISimpleMsgBox;
class  __declspec(uuid("{7D51904E-1645-4a8c-BDE0-0F4A44FC38C4}")) CSimpleMsgBoxImpl;

​ 有__declspec的一行将一个GUID赋值给ISimpleMsgBox，并且以后可以用__uuidof操作符来获取GUID。这两个东西(__declspec和__uuidof)都是微软的C++的扩展。

​ UUID 是通用唯一识别码（Universally Unique Identifier）的缩写，是一种软件建构的标准，亦为开放软件基金会组织在分布式计算环境领域的一部分。其目的是让分布式系统中的所有元素都能有唯一的辨识信息，而不需要通过中央控制端来做辨识信息的指定。如此一来，每个人都可以创建不与其它人冲突的UUID。在这样的情况下，就不需考虑数据库创建时的名称重复问题。目前最广泛应用的UUID，是微软公司的全局唯一标识符(GUID)。

这样便可以使用__uuidof关键字了

__uuidof使用方法介绍
属于VC++扩展语法
1
2
3
4
5
6
7
8
9
class Demo
{
};
class __declspec(uuid("B372C9F6-1959-4650-960D-73F20CD479BA")) Demo; 

int main( void )
{
    CLSID clsid = __uuidof(Demo); 
}

4.创建类厂(必须创建)

​ 每个类必须配有一个类厂,关注CreateInstance 和LockServer 方法. CoCreateInstance方法内部会生命周期依赖这个接口

​ 回过头看一下客户端的COM，它是如何以自己独立于语言的方式创建和销毁COM对象。客户端调用CoCreateInstance()创建新的COM对象。现在我们来看看它在服务器端是如何工作的。

​ 你每次实现组件对象类的时候，都要写一个旁类负责创建第一个组件对象类的实例。这个旁类就叫这个组件对象类的类工厂（class factory），其唯一目的是创建COM对象。之所以要一个类工厂，是因为语言无关的缘故。COM本身并不创建对象，因为它不是独立于语言的也不是独立于实现的。

​ 当某个客户端想要创建一个COM对象时，COM库就从COM服务器请求类工厂。然后类工厂创建COM对象并将它返回客户端。它们的通讯机制由函数DllGetClassObject()来提供。

​ 术语 “类工厂”和“类对象”实际上是一回事。没有那个单词能精确描述类工厂的作用和义，但正是这个工厂创建了COM对象，而不是COM类所为。将“类工厂”理解成“对象工厂”可能会更有助于理解（实际上MFC就是这样理解的——它的类工厂实现就叫做COleObjectFactory）。但“类工厂”是正式术语，所以本文也这样用。

​ 当COM库调用DllGetClassObject()时，它传递客户端请求的CLSID。服务器负责为所请求的CLSID创建者各类工厂并将它返回。类工厂本身就是一个组件对象类，并且实现CSimpleMsgBoxClassFactory接口。如果DllGetClassObject()调用成功，它返回一个CSimpleMsgBoxClassFactory指针给COM库，然后COM库用CSimpleMsgBoxClassFactory接口方法创建客户端所请求的COM对象实例。

.h文件：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
struct IClassFactory  : public IUnknown
{
    HRESULT CreateInstance( IUnknown* pUnkOuter, REFIID riid, void** ppvObject );
    HRESULT LockServer( BOOL fLock );
};
class CSimpleMsgBoxClassFactory : public IClassFactory
{
public:
    CSimpleMsgBoxClassFactory();
    virtual ~CSimpleMsgBoxClassFactory();
    //IUnknown方法
    ULONG AddRef();
    ULONG Release();
    HRESULT QueryInterface( REFIID riid, void** ppv );
    // IClassFactory方法
 　 HRESULT CreateInstance( IUnknown* pUnkOuter, REFIID riid, void** ppv );
    HRESULT LockServer( BOOL fLock );
protected:
    ULONG m_uRefCount;
};

其中，CreateInstance()是创建COM对象的方法。LockServer()在必要时让COM库增加或减少服务器的引用计数。

我们的类工厂是在一个叫做CSimpleMsgBoxClassFactory的C++类中实现的

.c文件：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// IClassFactory方法
STDMETHODIMP CSimpleMsgBoxClassFactory::CreateInstance ( IUnknown* pUnkOuter,
                                                         REFIID    riid,
                                                         void**    ppv )
{
    TRACE(">>> SimpleMsgBoxSvr: In CSimpleMsgBoxClassFactory::CreateInstance()\n" );
    
    //因为不支持聚合，所以这个参数pUnkOuter必须为NULL。
    if ( NULL != pUnkOuter )
        return CLASS_E_NOAGGREGATION;

    //检查指针ppv是不是void*类型。
    if ( IsBadWritePtr ( ppv, sizeof(void*) ))
        return E_POINTER;

    *ppv = NULL;

    //创建一个新的COM对象！
    CSimpleMsgBoxImpl* pMsgbox;
    pMsgbox = new CSimpleMsgBoxImpl;
    if ( NULL == pMsgbox )
        return E_OUTOFMEMORY;

    HRESULT hrRet;
    //用QI查询客户端所请求的对象接口。QueryInterface()简称QI()
    hrRet = pMsgbox->QueryInterface ( riid, ppv );
    
    //如果QI失败，则删除这个COM对象，因为客户端不能使用它（客户端没有这个对象的任何接口）。
    if ( FAILED(hrRet) )
        delete pMsgbox;

    return hrRet;
}

STDMETHODIMP CSimpleMsgBoxClassFactory::LockServer ( BOOL fLock )
{
    //根据fLock参数，增加/减少DLL引用计数。
    fLock ? g_uDllLockCount++ : g_uDllLockCount--;
    TRACE(">>> SimpleMsgBoxSvr: In CSimpleMsgBoxClassFactory::LockServer(), new DLL ref count = %d\n", g_uDllLockCount );
    return S_OK;
}

5.注册COM组件(手动注册）

万事俱备,现在要将其信息写入注册表,

5.1 实现DllRegisterServer和DllUnregisterServer方法,并将方法声明为STDAPI,表明属于导出函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
//DllRegisterServer（）创建告诉COM的注册项。
//服务器的位置及其线程模型。
STDAPI DllRegisterServer()
{
	HKEY  hCLSIDKey = NULL, hInProcSvrKey = NULL;
	LONG  lRet;
	TCHAR szModulePath [MAX_PATH];
	TCHAR szClassDescription[] = _T("SimpleMsgBox class");
	TCHAR szThreadingModel[]   = _T("Apartment");
	__try//__try __except是windows系统独有的异常处理模型，称为SEH，与标准的try catch相似。
   		{
			//在CLSID下为我们的COM服务器创建一个密钥。
			lRet = RegCreateKeyEx ( HKEY_CLASSES_ROOT, 
				_T("CLSID\\{7D51904E-1645-4a8c-BDE0-0F4A44FC38C4}"),
				0, NULL, REG_OPTION_NON_VOLATILE, 
				KEY_SET_VALUE | KEY_CREATE_SUB_KEY,NULL, &hCLSIDKey, NULL 
				);
				
			if ( ERROR_SUCCESS != lRet ) 
				return HRESULT_FROM_WIN32(lRet);

			//密钥的默认值是该类的人类可读描述。
			lRet = RegSetValueEx ( hCLSIDKey, NULL, 0, REG_SZ, 
									(const BYTE*) szClassDescription,
									sizeof(szClassDescription) 
								);

			if ( ERROR_SUCCESS != lRet )
				return HRESULT_FROM_WIN32(lRet);

			//创建InProcServer32键，其中包含有关我们的类的信息。
			lRet = RegCreateKeyEx ( hCLSIDKey, _T("InProcServer32"), 
									0, NULL, REG_OPTION_NON_VOLATILE,
									KEY_SET_VALUE, NULL, &hInProcSvrKey, NULL 
									);
    		if ( ERROR_SUCCESS != lRet )
				return HRESULT_FROM_WIN32(lRet);
 
			//InProcServer32键的默认值包含我们DLL的完整路径。
			GetModuleFileName ( g_hinstThisDll, szModulePath, MAX_PATH );
			lRet = RegSetValueEx ( hInProcSvrKey, NULL, 0, 
									REG_SZ, (const BYTE*) szModulePath,
									sizeof(TCHAR) * (lstrlen(szModulePath)+1) 
								  );

			if ( ERROR_SUCCESS != lRet )
        		return HRESULT_FROM_WIN32(lRet);

 			//ThreadingModel值告诉COM如何处理DLL中的线程。
			//公寓的概念超出了本文的范围，但是对于简单的单线程DLL，请使用Apartment。
			lRet = RegSetValueEx ( hInProcSvrKey, _T("ThreadingModel"), 0, REG_SZ,
									(const BYTE*) szThreadingModel, 
									sizeof(szThreadingModel) 
								  );

    		if ( ERROR_SUCCESS != lRet )
				return HRESULT_FROM_WIN32(lRet);
		}   

	__finally
		{
    		if ( NULL != hCLSIDKey )
				RegCloseKey ( hCLSIDKey );
			if ( NULL != hInProcSvrKey )
				RegCloseKey ( hInProcSvrKey );
   		}
		return S_OK;
}

 
//DllUnregisterServer（）删除了DllRegisterServer（）创建的注册项。
STDAPI DllUnregisterServer()
{
    //删除我们的注册表项。请注意，您必须从最深处删除
    //键并向上工作，因为在NT/2K上，RegDeleteKey（）不会删除
    //在NT/2K上具有子项的密钥。
    RegDeleteKey ( HKEY_CLASSES_ROOT, 
    			   _T("CLSID\\{7D51904E-1645-4a8c-BDE0-0F4A44FC38C4}\\InProcServer32") 
    			 );
    RegDeleteKey ( HKEY_CLASSES_ROOT, 
                   _T("CLSID\\{7D51904E-1645-4a8c-BDE0-0F4A44FC38C4}") 
                 );
    return S_OK;
}
5.2 定义def文件
1
2
3
4
5
EXPORTS
    DllRegisterServer   PRIVATE
    DllUnregisterServer PRIVATE
    DllGetClassObject   PRIVATE
    DllCanUnloadNow     PRIVATE
5.3 编译通过后使用regsvr32命令,注册此dll组件

在调用此com组件之前,必须通过cmd命令注册,很重要，DllRegisterServer将会成为入口点！！！

6.编写DllGetClassObject

只有通过全局函数DllGetClassObject,才可以创建类厂,这个方法com类库会去调用,其会根据CLSID返回一个类工厂(一个dll可能会有多个com类)

现在让我们深入DllGetClassObject()内部。它的原型是：

1
HRESULT DllGetClassObject ( REFCLSID rclsid, REFIID riid, void** ppv );

​ rclsid是客户端所请求的组件对象类的CLSID。这个函数必须返回指定组件对象类的类工厂。

​ 这里的两个参数： riid 和 ppv类似QI()的参数。不过在这个函数中，riid指的是COM库所请求的类工厂接口的IID。通常就是IID_IClassFactory。

​ 因为DllGetClassObject()也创建一个新的COM对象（类工厂），所以代码与IClassFactory::CreateInstance()十分相似。开始也是进行一些有效性检查以及初始化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
STDAPI DllGetClassObject ( REFCLSID rclsid, REFIID riid, void** ppv )
{
	HRESULT hrRet;
	CSimpleMsgBoxClassFactory* pFactory;
    TRACE(">>> SimpleMsgBoxSvr: In DllGetClassObject()\n");
    
    //检查客户端是否要求CSimpleMsgBoxImpl工厂。
	if ( !InlineIsEqualGUID ( rclsid, __uuidof(CSimpleMsgBoxImpl) ))
		return CLASS_E_CLASSNOTAVAILABLE;

	//检查ppv是否确实指向void*。
	if ( IsBadWritePtr ( ppv, sizeof(void*) ))
        return E_POINTER;

    *ppv = NULL;
   
    //下一步是创建一个类工厂对象。
    pFactory = new CSimpleMsgBoxClassFactory;//构造一个新的类工厂对象。

    if ( NULL == pFactory )
        return E_OUTOFMEMORY;
    /*
      这里的处理与CreateInstance()中所做的有所不同。在CreateInstance()中是调用了QI()，并且如果调用		失败，则删除COM对象。我们可以把自己假设成一个所创建的COM对象的客户端，调用AddRef()进行一次引用计		  数（COUNT = 1）。然后调用QI()。如果QI()调用成功，它将再一次用AddRef()进行引用计数（COUNT = 	  2）。如果QI()调用失败。引用计数将保持为原来的值（COUNT = 1）。在QI()调用之后，类工厂对象就使用完		 了，因此要调用Release()来释放它。如果QI()调用失败，这个对象将自我删除（因为引用计数将为零），所以	  最终结果是一样的。
    */

    // AddRef()工厂，因为我们正在使用它。
    pFactory->AddRef();

    //QI（）客户所需接口的工厂。
    hrRet = pFactory->QueryInterface ( riid, ppv );
    
    //我们已经完成了工厂工作，因此将其发布（）。
    pFactory->Release();

    return hrRet;
}

​ 第一个if语句检查rclsid参数。我们的服务器只有一个组件对象类，所以rclsid必须是CSimpleMsgBoxImpl类的CLSID。__uuidof操作符获取先前在__declspec(uuid())声明中指定的CsimpleMsgBoxImpl类的GUID

生命周期(非常重要)：

​ CoCreateInstance->CoGetClassObject->DllGetClassObject->IClassFactory->CreateInstance

再谈QueryInterface():

​ 前面讨论过QI()的实现，但还是有必要再看一看类工厂的QI()，因为它是一个很现实的例子，其中COM对象实现的不光是IUnknown。首先进行的是对ppv缓冲的有效性检查以及初始化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
HRESULT CSimpleMsgBoxClassFactory::QueryInterface( REFIID riid, void** ppv )
{
	HRESULT hrRet = S_OK;
    //检查指针ppv是不是void*类型
    if ( IsBadWritePtr ( ppv, sizeof(void*) ))
        return E_POINTER;
    //标准的QI初始化，将赋值为NULL.
    *ppv = NULL;
 　 //接下来检查riid，看看它是不是类工厂实现的接口之一：IUnknown 或 IclassFactory。
    // 如果客户端请求一个有效接口，则给 *ppv.
    if ( InlineIsEqualGUID ( riid, IID_IUnknown ))
    {
       *ppv = (IUnknown*) this;
    }
    else if ( InlineIsEqualGUID ( riid, IID_IClassFactory ))
    {
      *ppv = (IClassFactory*) this;
    }
    else
    {
       hrRet = E_NOINTERFACE;
    }
    //最后，如果riid是有效接口，则调用接口的AddRef()，然后返回。
   //如果返回有效接口指针，则调用AddRef() 
    if ( S_OK == hrRet ) 
    {
       ((IUnknown*) *ppv)->AddRef();
    }
    return hrRet;
}

7.调用com组件

当某一客户端想要创建一个ISimpleMsgBox COM对象时，它应该用下面这样的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void DoMsgBoxTest(HWND hMainWnd)
{
	ISimpleMsgBox* pIMsgBox;
	HRESULT hr;
    hr = CoCreateInstance ( __uuidof(CSimpleMsgBoxImpl), 
                           NULL,					 //非聚合
                           CLSCTX_INPROC_SERVER,     //进程内服务器
                            __uuidof(ISimpleMsgBox), //所请求接口的IID
                           (void**) &pIMsgBox        //返回的接口指针的地址
                          );

    if ( FAILED(hr) )
        return;
	//然后调用DoSimpleMsgBox()方法并释放接口。
    pIMsgBox->DoSimpleMsgBox ( hMainWnd, _bstr_t("Hello COM!") );
    pIMsgBox->Release();
}

以上步骤不可以省略,可以看到创建一个com组件是比较麻烦的一个流程,很容易出错或者先创建一个类工厂

1
2
3
4
5
6
7
8
9

HRESULT hr;
IClassFactory *pc=NULL;
hr=::CoGetClassObject(__uuidof(CSimpleMsgBoxImpl), 
                      CLSCTX_INPROC_SERVER,
                      NULL, 
                      IID_IClassFactory, 
                      (void**) &pc 
                     );
赏

谢谢你请我吃糖果！

微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家