COM是更好的C++

最新推荐文章于 2024-06-21 13:59:32 发布

andylin02

最新推荐文章于 2024-06-21 13:59:32 发布

阅读量595

点赞数

分类专栏： C/C++ 文章标签： math.h interface dll library null parameters

C/C++ 专栏收录该内容

1243 篇文章 0 订阅

订阅专栏

COM是更好的C++

C++：

如果是静态连接的话，发布一个类库，此时类库的可执行代码将成为客户应用中不可分割的一部分。当三个应用程序都使用这个库时，那么每个可执行文件都包含类库代码。一旦类库厂商发现类库有一个缺陷后，发布一个新的类库，此时需要编译所有运用此类库的应用程序。

应用程序A＋CMath.obj

应用程序B＋CMath.obj

应用程序C＋CMath.obj

DLL：

代码共享，解决上面问题的是将类库做成动态链接库(DLL ，Dynamic Link Library)的形式封装起来。类库所有方法都将被加到dll 的引出表(export list)中，而且链接器将会产生一个引入库(import library)。这个库暴露了库的方法成员的符号。当客户链接引入库时，有一些存根会被引入到可执行文件中，它在运行时通知装载器动态装载dll。

应用程序A＋CMath.lib(引入库） /

应用程序B＋CMath.lib(引入库） | CMath.dll（共享一份代码）

应用程序C＋CMath.lib(引入库） /

COM：

因为C++类那既是接口也是实现。这里需要把接口从实现中分离出来才能提供二进制组件结构。此时需要有二个C++类，一个作为接口类另一个作为实现类。

COM基础

返回值：

COM要求所有的方法都会返回一个HRESULT类型的错误号。HRESULT 其实就一个类型定义；typedef LONG HRESULT。

有关HRESULT的定义见 winerror.h 文件

// Values are 32 bit values layed out as follows:

// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1

// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0

// +-+----+-------------------------+---------------------------------+

// |S| Res| Facility | Code |

// +-+----+-------------------------+---------------------------------+

// where

// S - is the severity code

// 0 - Success

// 1 - Error

// Res- is a reserved bit

// Facility - is the facility code

// Code - is the facility''s status code

IDL：

每个标准的COM组件都需要一个接口定义文件，文件的扩展名为IDL。让我们看IUnknow接口的定义文件是怎样的。

[

local,

object,

uuid(00000000-0000-0000-C000-000000000046),

pointer_default(unique)

]

interface IUnknown

{

typedef [unique] IUnknown *LPUNKNOWN;

cpp_quote("//")

cpp_quote("// IID_IUnknown and all other system IIDs are provided in UUID.LIB")

cpp_quote("// Link that library in with your proxies, clients and servers")

cpp_quote("//")

HRESULT QueryInterface(

[in] REFIID riid,

[out, iid_is(riid)] void **ppvObject);

ULONG AddRef();

ULONG Release();

}

[local]属性禁止产生网络代码。

[object]属性是表明定义的是一个COM接口，而不是DEC风格的接口。

[uuid]属性给接口一个GUID。

[unique]属性表明null(空)指针为一个合法的参数值。

[pointer_defaul]属性所有的内嵌指针指定一个默认指针属性

typedef [unique] IUnknown *LPUNKNOWN;这是一个类型定义

cpp_quote这个比较有趣，这是一个在idl文件写注解的方法。这些注解将保存到***.h和***_i.c文件中

[in]表示这个参数是入参

[out]表示这个参数是出参

[iid_is(riid)]表示这个参数需要前一个的riid 参数。

Iunknown：

COM要求(最基本的要求)所有的接口都需要从IUnknown接口直接或间接继承。
IUnkown接口定义了三个方法。

HRESULT QueryInterface([in] REFIID riid,[out] void **ppv);

ULONG AddRef();

ULONG Release();

其中 AddReft() 和Release()负责对象引用计数用的，而 QueryInterface()方法是用于查询所实现接口用的。每当COM组件被引用一次就应调用一次AddRef()方法。而当客户端在释放COM组件的某个接口时就需要调用Release()方法。
这里所讲的请在下面的例子仔细体会。

COM简单的例子

此例子共有四个文件组成：
　

文件名                      说明

Interface.h                 接口类定义文件

Math.h和Math.cpp            实现类文件

Simple.cpp 主函数文件       这里用来当作COM的客户端

interface.h 文件：

#ifndef INTERFACE_H

#define INTERFACE_H

#include

//{7C8027EA-A4ED-467c-B17E-1B51CE74AF57}

static const GUID IID_ISimpleMath =

{ 0x7c8027ea, 0xa4ed, 0x467c, { 0xb1, 0x7e, 0x1b, 0x51, 0xce, 0x74, 0xaf, 0x57 } };

//{CA3B37EA-E44A-49b8-9729-6E9222CAE84F}

static const GUID IID_IAdvancedMath =

{ 0xca3b37ea, 0xe44a, 0x49b8, { 0x97, 0x29, 0x6e, 0x92, 0x22, 0xca, 0xe8, 0x4f } };

interface ISimpleMath : public IUnknown

{

public:

virtual int Add(int nOp1, int nOp2) = 0;

virtual int Subtract(int nOp1, int nOp2) = 0;

virtual int Multiply(int nOp1, int nOp2) = 0;

virtual int Divide(int nOp1, int nOp2) = 0;

};

interface IAdvancedMath : public IUnknown

{

public:

virtual int Factorial(int nOp1) = 0;

virtual int Fabonacci(int nOp1) = 0;

};

#endif

此文件首先 #include 将 IUnknown 接口定义文件包括进来。
接下来定义了两个接口，GUID（Globally Unique Identifier全局唯一标识符）它能保证时间及空间上的唯一。
ISmipleMath接口里定义了四个方法，而IAdvancedMath接口里定义了二个方法。这些方法都是虚函数，而整个 ISmipleMath 与 IAdvancedMath 抽象类就作为二进制的接口。

math.h文件：

#include "interface.h"

class CMath : public ISimpleMath, public IAdvancedMath

{

private:

ULONG m_cRef;

private:

int calcFactorial(int nOp);

int calcFabonacci(int nOp);

public:

//IUnknown Method

STDMETHOD(QueryInterface)(REFIID riid, void **ppv);

STDMETHOD_(ULONG, AddRef)();

STDMETHOD_(ULONG, Release)();

// ISimpleMath Method

int Add(int nOp1, int nOp2);

int Subtract(int nOp1, int nOp2);

int Multiply(int nOp1, int nOp2);

int Divide(int nOp1, int nOp2);

// IAdvancedMath Method

int Factorial(int nOp);

int Fabonacci(int nOp);

};

此类为实现类，他实现了ISmipleMath和IAdvancedMath两个接口类(当然也可以只实现一个接口类)。
请注意：m_cRef 是用来对象计数用的。当 m_cRef 为0组件对象应该自动删除。

math.cpp文件：

#include "interface.h"

#include "math.h"

STDMETHODIMP CMath::QueryInterface(REFIID riid, void **ppv)

{// 这里这是实现dynamic_cast的功能，但由于dynamic_cast与编译器相关。

if(riid == IID_ISimpleMath)

*ppv = static_cast(this);

else if(riid == IID_IAdvancedMath)

*ppv = static_cast(this);

else if(riid == IID_IUnknown)

*ppv = static_cast(this);

else {

*ppv = 0;

return E_NOINTERFACE;

}

reinterpret_cast(*ppv)->AddRef(); //这里要这样是因为引用计数是针对组件的

return S_OK;

}

STDMETHODIMP_(ULONG) CMath::AddRef()

{

return ++m_cRef;

}

STDMETHODIMP_(ULONG) CMath::Release()

{

ULONG res = --m_cRef; // 使用临时变量把修改后的引用计数值缓存起来

if(res == 0) // 因为在对象已经销毁后再引用这个对象的数据将是非法的

delete this;

return res;

}

int CMath::Add(int nOp1, int nOp2)

{

return nOp1+nOp2;

}

int CMath::Subtract(int nOp1, int nOp2)

{

return nOp1 - nOp2;

}

int CMath::Multiply(int nOp1, int nOp2)

{

return nOp1 * nOp2;

}

int CMath::Divide(int nOp1, int nOp2)

{

return nOp1 / nOp2;

}

int CMath::calcFactorial(int nOp)

{

if(nOp <= 1)

return 1;

return nOp * calcFactorial(nOp - 1);

}

int CMath::Factorial(int nOp)

{

return calcFactorial(nOp);

}

int CMath::calcFabonacci(int nOp)

{

if(nOp <= 1)

return 1;

return calcFabonacci(nOp - 1) + calcFabonacci(nOp - 2);

}

int CMath::Fabonacci(int nOp)

{

return calcFabonacci(nOp);

}

CMath::CMath()

{

m_cRef=0;

}

此文件是CMath类定义文件。

simple.cpp：

#include "math.h"

#include

using namespace std;

int main(int argc, char* argv[])

{

ISimpleMath *pSimpleMath = NULL;//声明接口指针

IAdvancedMath *pAdvMath = NULL;

//创建对象实例，我们暂时这样创建对象实例，COM有创建对象实例的机制

CMath *pMath = new CMath;

//查询对象实现的接口ISimpleMath

pMath->QueryInterface(IID_ISimpleMath, (void **)&pSimpleMath);

if(pSimpleMath)

cout << "10 + 4 = " << pSimpleMath->Add(10, 4) << endl;

//查询对象实现的接口IAdvancedMath

pSimpleMath->QueryInterface(IID_IAdvancedMath, (void **)&pAdvMath);

if(pAdvMath)

cout << "10 Fabonacci is " << pAdvMath->Fabonacci(10) << endl;

pAdvMath->Release();

pSimpleMath->Release();

return 0;

}

此文件相当于客户端的代码，首先创建一个CMath对象,再根据此对象去查询所需要的接口，如果正确得到所需接口指针，再调用接口的方法，最后再将接口的释放掉。

Math组件的二进制结构图：

小结：

例子从严格意义上来并不是真正的COM组件(他不是dll)，但他已符合COM的最小要求(实现IUnknown接口)。接下来我们来做一COM dll。

创建一个COM组件

创建过程示意图如下:

在这一过程中我们将完成三个步骤：创建dll的入口函数，定义接口文件，实现注册功能

1．一个类型为win32 dll工程：

创建一个名为MathCOM的win32 dll工程。
在向导的第二步选择"A smiple dll project"选项。当然如果你选择一个空的工程，那你自己完成DllMain定义吧。

2．接口文件：

生成一个名为MathCOM.idl的接口文件。并将此文件加入到刚才创建的那个工程里。

//MathCOM.idl文件

// MathCOM.idl : IDL source for MathCOM.dll

// This file will be processed by the MIDL tool to

// produce the type library (MathCOM.tlb) and marshalling code.

import "oaidl.idl";

import "ocidl.idl";

[

uuid(FAEAE6B7-67BE-42a4-A318-3256781E945A),

helpstring("ISimpleMath Interface"),

object,

pointer_default(unique)

]

interface ISimpleMath : IUnknown

{

HRESULT Add([in]int nOp1,[in]int nOp2,[out,retval]int * pret);

HRESULT Subtract([in]int nOp1,[in]int nOp2,[out,retval]int * pret);

HRESULT Multiply([in]int nOp1,[in]int nOp2,[out,retval] int * pret);

HRESULT Divide([in]int nOp1,[in]int nOp2,[out,retval]int * pret);

};

[

uuid(01147C39-9DA0-4f7f-B525-D129745AAD1E),

helpstring("IAdvancedMath Interface"),

object,

pointer_default(unique)

]

interface IAdvancedMath : IUnknown

{

HRESULT Factorial([in]int nOp1,[out,retval]int * pret);

HRESULT Fabonacci([in]int nOp1,[out,retval]int * pret);

};

[

uuid(CA3B37EA-E44A-49b8-9729-6E9222CAE844),

version(1.0),

helpstring("MATHCOM 1.0 Type Library")

]

library MATHCOMLib

{

importlib("stdole32.tlb");

importlib("stdole2.tlb");

[

uuid(3BCFE27E-C88D-453C-8C94-F5F7B97E7841),

helpstring("MATHCOM Class")

]

coclass MATHCOM

{

[default] interface ISimpleMath;

interface IAdvancedMath;

};

在编译此工程之前请检查Project/Setting/MIDL中的设置。正确设置如下图：

在正确设置后，如编译无错误，那么将在工程的目录下产生四个

文件名
作用

MathCOM.h
接口的头文件，如果想声明或定义接口时使用此文件

MathCOM_i.c
定义了接口和类对象以及库，只有在要使用到有关与GUID有关的东西时才引入此文件，此文件在整个工程中只能引入一次，否则会有重复定义的错误

MathCOM_p.c
用于存根与代理

dlldata.c
不明

3．增加注册功能：

作为COM必须要注册与注销的功能。
增加一个MathCOM.def文件，DEF文件是模块定义文件（Module Definition File）。它允许引出符号被化名为不同的引入符号。

//MathCOM.def文件

; MathCOM.def : Declares the module parameters.

LIBRARY "MathCOM.DLL"

EXPORTS

DllCanUnloadNow @1 PRIVATE

DllGetClassObject @2 PRIVATE

DllRegisterServer @3 PRIVATE

DllUnregisterServer @4 PRIVATE

DllUnregisterServer　这是函数名称 @4＜――这是函数序号 PRIVATE

接下来大致介绍一下DllRegisterServer（）和DllUnregisterServer()。（其他两个函数的作用将在后面介绍）

DllRegisterServer()和DllUnregisterServer()

DllRegisterServer() 函数的作用是将COM服务器注册到本机上。

DllUnregisterServer() 函数的作用是将COM服务器从本机注销。

MathCOM.cpp文件：

现在请将 MathCOM.cpp 文件修改成如下：

// MATHCOM.cpp : Defines the entry point for the DLL application.

#include "stdafx.h"

#include

#include "MathCOM.h"

//standard self-registration table

const char * g_RegTable[][3]={

{"CLSID//{3BCFE27E-C88D-453C-8C94-F5F7B97E7841}",0,"MathCOM"},

{"CLSID//{3BCFE27E-C88D-453C-8C94-F5F7B97E7841}//InprocServer32",

(const char * )-1 /*表示文件名的值*/},

{"CLSID//{3BCFE27E-C88D-453C-8C94-F5F7B97E7841}//ProgID",0,"tulip.MathCOM.1"},

{"tulip.MathCOM.1",0,"MathCOM"},

{"tulip.MathCOM.1//CLSID",0,"{3BCFE27E-C88D-453C-8C94-F5F7B97E7841}"},

};

HINSTANCE g_hinstDll;

BOOL APIENTRY DllMain( HANDLE hModule,

DWORD ul_reason_for_call,

LPVOID lpReserved

)

{

g_hinstDll=(HINSTANCE)hModule;

return TRUE;

}

/*********************************************************************

* Function Declare : DllUnregisterServer

* Explain : self-unregistration routine

* Parameters :

* void --

* Return :

* STDAPI --

* Author : tulip

* Time : 2003-10-29 19:07:42

*********************************************************************/

STDAPI DllUnregisterServer(void)

{

HRESULT hr=S_OK;

char szFileName [MAX_PATH];

::GetModuleFileName(g_hinstDll,szFileName,MAX_PATH);

int nEntries=sizeof(g_RegTable)/sizeof(*g_RegTable);

for(int i =0;SUCCEEDED(hr)&&i<nEntries;i++)

{

const char * pszKeyName=g_RegTable[i][0];

long err=::RegDeleteKey(HKEY_CLASSES_ROOT,pszKeyName);

if(err!=ERROR_SUCCESS)

hr=S_FALSE;

}

return hr;

}

/*********************************************************************

* Function Declare : DllRegisterServer

* Explain : self Registration routine

* Parameters :

* void --

* Return :

* STDAPI --

* Author : tulip

* Time : 2003-10-29 19:43:51

*********************************************************************/

STDAPI DllRegisterServer(void)

{

HRESULT hr=S_OK;

char szFileName [MAX_PATH];

::GetModuleFileName(g_hinstDll,szFileName,MAX_PATH);

int nEntries=sizeof(g_RegTable)/sizeof(*g_RegTable);

for(int i =0;SUCCEEDED(hr)&&i<nEntries;i++)

{

const char * pszKeyName=g_RegTable[i][0];

const char * pszValueName=g_RegTable[i][1];

const char * pszValue=g_RegTable[i][2];

if(pszValue==(const char *)-1)

{

pszValue=szFileName;

}

HKEY hkey;

long err=::RegCreateKey(HKEY_CLASSES_ROOT,pszKeyName,&hkey);

if(err==ERROR_SUCCESS)

{

err=::RegSetValueEx( hkey,

pszValueName,

REG_SZ,

( const BYTE*)pszValue,

( strlen(pszValue)+1 ) );

::RegCloseKey(hkey);

}

if(err!=ERROR_SUCCESS)

{

::DllUnregisterServer();

hr=E_FAIL;

}

return hr;

}

STDAPI DllGetClassObject(REFCLSID rclsid ,REFIID riid,void **ppv)

{

return CLASS_E_CLASSNOTAVAILABLE;

}

STDAPI DllCanUnloadNow(void)

{

return E_FAIL;

}

我只是在此文件中加几个必要的头文件和几个全局变量。并实现了 DllRegisterServer（）和DllUnregisterServer()。而对于其他两引出函数我只返回一个错误值罢了。

小结：

现在我们的工程中应该有如下文件：
　

文件名
作用

Stdafx.h和stdafx.cpp
预编译文件

MathCOM.cpp
Dll入口函数及其他重要函数定义的地方

MathCOM.def
模块定义文件

MathCOM.idl
接口定义文件（在1.2后如果编译的话应该还有四个文件）

好了到现在，我的所谓COM已经实现注册与注销功能。

如果在命令行或"运行"菜单下项执行如下"regsvr32 绝对路径＋MathCOM.dll"就注册此COM组件。在执行完此命令后，请查看注册表项的HKEY_CLASSES_ROOT/CLSID项看看3BCFE27E-C88D-453C-8C94-F5F7B97E7841这一项是否存在。

如同上方法再执行一下"regsvr32 -u 绝对路径＋MathCOM.dll"，再看看注册表。
其实刚才生成的dll根本不是COM组件，哈哈！！！因为他没有实现DllGetClassObject()也没有实现ISmipleMath和IAdvancedMath两个接口中任何一个。
让我们继续前行吧！！！

4．实现ISmipleMath,IAdvancedMath接口和DllGetClassObject()

实现ISmipleMath和IAdvancedMath接口

让我们将原来的 CMath 类修改来实现ISmipleMath接口和IAdvancedMath接口。
修改的地方如下：

1) Math.h文件

/*@**#---2003-10-29 21:33:44 (tulip)---#**@

#include "interface.h"*/

#include "MathCOM.h"//新增加的，以替换上面的东东

class CMath : public ISimpleMath,

public IAdvancedMath

{

private:

ULONG m_cRef;

private:

int calcFactorial(int nOp);

int calcFabonacci(int nOp);

public:

CMath();

//IUnknown Method

STDMETHOD(QueryInterface)(REFIID riid, void **ppv);

STDMETHOD_(ULONG, AddRef)();

STDMETHOD_(ULONG, Release)();

// ISimpleMath Method

STDMETHOD (Add)(int nOp1, int nOp2,int * pret);

STDMETHOD (Subtract)(int nOp1, int nOp2,int *pret);

STDMETHOD (Multiply)(int nOp1, int nOp2,int *pret);

STDMETHOD (Divide)(int nOp1, int nOp2,int * pret);

// IAdvancedMath Method

STDMETHOD (Factorial)(int nOp,int *pret);

STDMETHOD (Fabonacci)(int nOp,int *pret);

};

2) Math.cpp文件

/*@**#---2003-10-29 21:32:35 (tulip)---#**@

#include "interface.h" */

#include "math.h"

STDMETHODIMP CMath::QueryInterface(REFIID riid, void **ppv)

{// 这里这是实现dynamic_cast的功能，但由于dynamic_cast与编译器相关。

if(riid == IID_ISimpleMath)

*ppv = static_cast(this);

else if(riid == IID_IAdvancedMath)

*ppv = static_cast(this);

else if(riid == IID_IUnknown)

*ppv = static_cast(this);

else {

*ppv = 0;

return E_NOINTERFACE;

}

reinterpret_cast(*ppv)->AddRef(); //这里要这样是因为引用计数是针对组件的

return S_OK;

}

STDMETHODIMP_(ULONG) CMath::AddRef()

{

return ++m_cRef;

}

STDMETHODIMP_(ULONG) CMath::Release()

{

ULONG res = --m_cRef; // 使用临时变量把修改后的引用计数值缓存起来

if(res == 0) // 因为在对象已经销毁后再引用这个对象的数据将是非法的

delete this;

return res;

}

STDMETHODIMP CMath::Add(int nOp1, int nOp2,int * pret)

{

*pret=nOp1+nOp2;

return S_OK;

}

STDMETHODIMP CMath::Subtract(int nOp1, int nOp2,int * pret)

{

*pret= nOp1 - nOp2;

return S_OK;

}

STDMETHODIMP CMath::Multiply(int nOp1, int nOp2,int * pret)

{

*pret=nOp1 * nOp2;

return S_OK;

}

STDMETHODIMP CMath::Divide(int nOp1, int nOp2,int * pret)

{

*pret= nOp1 / nOp2;

return S_OK;

}

int CMath::calcFactorial(int nOp)

{

if(nOp <= 1)

return 1;

return nOp * calcFactorial(nOp - 1);

}

STDMETHODIMP CMath::Factorial(int nOp,int * pret)

{

*pret=calcFactorial(nOp);

return S_OK;

}

int CMath::calcFabonacci(int nOp)

{

if(nOp <= 1)

return 1;

return calcFabonacci(nOp - 1) + calcFabonacci(nOp - 2);

}

STDMETHODIMP CMath::Fabonacci(int nOp,int * pret)

{

*pret=calcFabonacci(nOp);

return S_OK;

}

CMath::CMath()

{

m_cRef=0;

}

COM组件调入大致过程

· 1) COM库初始化使用CoInitialize序列函数（应用程序）

· 2）激活COM（应用程序）

· 3) 通过注册表项将对应的dll调入COM库中（COM库）

· 4) 调用COM组件内的DllGetClassObject()函数（COM组件）

· 5）通过类厂返回接口指针（COM库）这一步不是必需的

DllGetClassObject()实现
在MathCOM.cpp里加入下列语句，

#include "math.h"

#include "MathCOM_i.c"

并将MathCOM.cpp里的DllGetClassObject()修改成如下：

/*********************************************************************

* Function Declare : DllGetClassObject

* Explain :

* Parameters :

* REFCLSID rclsid --

* REFIID riid --

* void **ppv --

* Return :

* STDAPI --

* Author : tulip

* Time : 2003-10-29 22:03:53

*********************************************************************/

STDAPI DllGetClassObject(REFCLSID rclsid ,REFIID riid,void **ppv)

{

static CMath *pm_math=new CMath;

if(rclsid==CLSID_MATHCOM)

return pm_math->QueryInterface(riid,ppv);

return CLASS_E_CLASSNOTAVAILABLE;

}

5．测试

接下来我们写个客户端程序对此COM进行测试。
新建一个空的名为 TestMathCOM 的 win32 Console 工程，将它添加到 MathCOM workspace 中。
在 TestMathCOM 工程里添加一个名为 main.cpp 的文件，此文件的内容如下：

//main.cpp文件

#include

#include "../MathCOM.h"//这里请注意路径

#include "../MathCOM_i.c"//这里请注意路径

#include

using namespace std;

void main(void)

{

//初始化COM库

HRESULT hr=::CoInitialize(0);

ISimpleMath * pSimpleMath=NULL;

IAdvancedMath * pAdvancedMath=NULL;

int nReturnValue=0;

hr=::CoGetClassObject(CLSID_MATHCOM,

CLSCTX_INPROC,

NULL,IID_ISimpleMath,

(void **)&pSimpleMath);

if(SUCCEEDED(hr))

{

hr=pSimpleMath->Add(10,4,&nReturnValue);

if(SUCCEEDED(hr))

cout << "10 + 4 = " <<NRETURNVALUE<< endl;

nReturnValue=0;

}

// 查询对象实现的接口IAdvancedMath

hr=pSimpleMath->QueryInterface(IID_IAdvancedMath, (void **)&pAdvancedMath);

if(SUCCEEDED(hr))

{

hr=pAdvancedMath->Fabonacci(10,&nReturnValue);

if(SUCCEEDED(hr))

cout << "10 Fabonacci is " << nReturnValue << endl;

}

pAdvancedMath->Release();

pSimpleMath->Release();

::CoUninitialize();

::system("pause");

return ;

}

小结：

到现在我们应该有 2 个工程和 8 个文件，具体如下：
　

工程
文件
作用

MathCOM
Stdafx.h 和 stdafx.cpp
预编译文件

　
MathCOM.cpp
Dll入口函数及其他重要函数定义的地方

　
MathCOM.def
模块定义文件

　
MathCOM.idl
接口定义文件（在1.2后如果编译的话应该还有四个文件）

　
math.h和math.cpp
ISmipleMath,IadvancedMath接口的实现类

TestMathCOM
Main.cpp
MathCOM的客户端，用于测试MathCOM组件

在此部分中我们已经完成一个可以实用的接近于完整的 COM组件。我们完成了此COM组件的客户端。如果你已经创建COM实例的话，你可能会发现在此部分的客户端并不是用CoCreateInstance()来创建COM实例，那是因为我们还没有在此COM组件里实现IClassFactory接口（此接口在下一部分实现）。
通过这个例子，我希望大家明白以下几点：

· 1) DllGetClassObject（）的作用，请参看COM组件调入大致过程这一节，同时也请将断点打在DllGetClassObject()函数上，仔细看看他的实现（在没有实现IClassFactory接口的情况下）和他的传入参数。

· 2) 为什么在这个客户端程序里不使用CoCreateInstance()来创建COM实例而使用CoGetClassObject()来创建COM实例。你可以试着用CoCreateInstance()来创建Cmath,看看DllGetClassObject()的第一参数是什么？

· 3) 实现IClassFactory接口不是必需的，但应该说是必要的（如何实现请看下一章）

· 4) 应掌握DllRegisterServer()和DllUnregisterServer()的实现。

· 5) 客户端在调用COM组件时需要那几个文件（只要由idl文件产生的两个文件）

类厂：

在上节里，我们创建组件实例及得到接口指针的过程如下：首先在客户端的用户调用COM API CoCreateInstance，这个函数调用另一个COM API CoGetClassObject获得组件的类厂接口指针，此时COM库会加载组件DLL（EXE的处理方式稍有不同，我们会在以后的章节中讲解）中的导出函数DllGetClassObject()，获得类厂接口指针后马上调用类厂的方法CreateInstance创建对象实例并通过组件对象的QueryInterface()得到用需的接口指针。

此前我们所实现的并不是真正完整的COM组件，现在我们来实现一个真正的COM组件，实现组件创建机制的核心：类厂－创建组件对象的对象。COM为通用化以及在管理上统一和方便，COM规范要求所有标准COM组件都应实现IClassFactory接口(有关IClassFactory的功能各个方法的作用请参阅MSND/Welcome to the msnd library/msnd resource/selected online columns/Dr.GUI online/Dr. GUI on Components, COM, and ATL/part 5)

2.2 增加IClassFactory的实现

此次我们将修改的文件如下

工程名
文件名
修改属性

MathCOM
MathCOM.cpp
修改

　
MathFactory.h和MathFactory.cpp
新增

TestMathCOM
Main.cpp
修改

2.2.1 MathCOM.cpp

#include "math.h"

#include "MathCOM_i.c"

#include "MathFactory.h"

// 服务器锁，如果标志为S_OK，就可以卸载当前组件的服务器，

// 关于引用计数及服务器跟COM对象的关系，后绪章节再讲解

LONG g_cObjectAndLocks=0;

//standard self-registration table

const char * g_RegTable[][3]={………………….

…………………………

STDAPI DllGetClassObject(REFCLSID rclsid ,REFIID riid,void **ppv)

{

if(rclsid==CLSID_MATHCOM)

{

CMathFactory *pFactory = new CMathFactory; // 创建类厂对象

if(pFactory == NULL)

return E_OUTOFMEMORY;

///

// 一般情况下COM希望用户只查询IClassFactory,

// IClassFactory2及IUnknow

HRESULT hr = pFactory->QueryInterface(iid, ppv);

return hr;

}

return CLASS_E_CLASSNOTAVAILABLE;

}

STDAPI DllCanUnloadNow(void)

{

return (g_cObjectAndLocks==0)?S_OK:E_FAIL;

}

2.2.2 MathFactory.h

// MathFactory.h: interface for the CMathFactory class.

#ifndef MATHFACTORY_H

#define MATHFACTORY_H

#include

class CMathFactory :public IClassFactory

{

public:

CMathFactory():m_cRef(0){}

//IUnknow Method

STDMETHODIMP QueryInterface(REFIID,void**);

STDMETHODIMP_(ULONG) AddRef();

STDMETHODIMP_(ULONG) Release();

//IClassFactory Method

STDMETHODIMP CreateInstance(IUnknown * ,REFIID ,void **);

STDMETHODIMP LockServer(BOOL fLock);

protected:

LONG m_cRef;

};

#endif

2.2.3 MathFactory.cpp

// MathFactory.cpp: implementation of the CMathFactory class.

#include "math.h"

#include "MathFactory.h"

extern LONG g_cObjectAndLocks;

// Construction/Destruction

STDMETHODIMP_(ULONG) CMathFactory::AddRef(void)

{

return InterlockedIncrement(&m_cRef);

}

STDMETHODIMP_(ULONG) CMathFactory::Release(void)

{

return ::InterlockedDecrement(&m_cRef);

}

STDMETHODIMP CMathFactory::QueryInterface(REFIID riid,void ** ppv)

{

*ppv=NULL;

if(riid==IID_IUnknown||riid==IID_IClassFactory)

{

*ppv=static_cast(this);

reinterpret_cast(*ppv)->AddRef();

return S_OK;

}

else

return (*ppv=0),E_NOINTERFACE;

}

STDMETHODIMP CMathFactory::CreateInstance(IUnknown * pUnkOuter,REFIID riid,void ** ppv)

{

*ppv=NULL;

// 现在不支持聚合

if(pUnkOuter!=NULL)

return CLASS_E_NOAGGREGATION;

CMath * pMath=new CMath;

if(pMath==NULL)

return E_OUTOFMEMORY;

HRESULT hr=pMath->QueryInterface(riid,ppv);

if(FAILED(hr))

delete pMath;

return hr;

}

STDMETHODIMP CMathFactory::LockServer(BOOL fLock)

{

if(fLock)

::InterlockedIncrement(&g_cObjectAndLocks);

else

::InterlockedDecrement(&g_cObjectAndLocks);

return NOERROR;

}

2.2.4 main.cpp

#include

#include "../MathCOM.h"

#include "../MathCOM_i.c"

#include

using namespace std;

void main(void)

{

//初始化COM库

HRESULT hr=::CoInitialize(0);

ISimpleMath * pSimpleMath=NULL;

IAdvancedMath * pAdvancedMath=NULL;

int nReturnValue=0;

//如果还想用CoCreateInstance()得到接口指针，请如下使用先传一个IClassFactory接口

/*************** 这里请注意 *****************/

// 方法一

hr = ::CoCreateInstance(CLSID_MATHCOM,

CLSCTX_INPROC,

NULL,

IID_ISimpleMath,

(void*)&pSimpleMath);

///

// 这个方法的好处是不需要太多的代码, 让COM来处理真正的类厂创建对象的过程.

// 同时这个函数的改进版CoCreateInstanceEx在分布式对象应用中可以一次取回多

// 个接口指针. 避免过多的在网络上浪费时间关于这个函数的用法我也会在以后的

// 章节中讲解. 您也可以参考MSDN或相关书藉

// 方法二

IClassFactory * pClassFactory=NULL; // 类厂接口指针

// 获取对象的类厂接口指针

hr=::CoGetClassObject(CLSID_MATHCOM,

CLSCTX_INPROC,

NULL,

IID_IClassFactory,

(void**)&pClassFactory);

// 真正创建对象

hr = pClassFactory->CreateInstance(NULL,IID_ISimpleMath,(void**)&pSimpleMath);

// 此方法的好处在于可以一次创建多个对象, 不需要

// 下面测试 IDispatch 接口

if(SUCCEEDED(hr))

{

hr=pSimpleMath->Add(10,4,&nReturnValue);

if(SUCCEEDED(hr))

cout << "10 + 4 = " <<NRETURNVALUE<< endl;

nReturnValue=0;

}

//查询对象实现的接口IAdvancedMath

hr=pSimpleMath->QueryInterface(IID_IAdvancedMath, (void **)&pAdvancedMath);

if(SUCCEEDED(hr))

{

hr=pAdvancedMath->Fabonacci(10,&nReturnValue);

if(SUCCEEDED(hr))

cout << "10 Fabonacci is " << nReturnValue << endl;

}

pAdvancedMath->Release();

pSimpleMath->Release();

::CoUninitialize();

return ;

}

小结：

在此部分我们实现了IClassFactory接口，可以说实现了一个真正的COM对象了，我们可以在C＋＋中使用一般的COM客户端方法创建对象，执行方法等。但是不知道用户有没有发现，COM的目标是语言无关，像VB中不支持指针，脚本是解释执行（但是COM需要在编译期间绑定接口调用）。怎么办呢？有没有办法实现呢？方法当然是有的。接下来的一节我不为大家讲解为不支持指针的语言而提供支持的特殊接口IDispatch －派发接口（也称调度接口）。为上述语言提供一个效率上稍差但灵活性更高的解决方法。接下来这一章让我们实现IDispatch接口，以便在脚本环境中使用我们的COM组件。

</nEntries;i++)</nEntries;i++)