2.类厂.

 实际上CoCreateInstance并没有创建组件,而是创建了一个被称为类厂的组件.
 类厂唯一功能就是创建其他组件.

 精确点讲就是.某个特定类厂将创建某个特定CLSID相应的组件. 客户可以通过类厂所支持的接口来对类厂创建组件的过程加以控制. 创建组件的标准接口是 IClassFactory,用CoCreateInstance创建的组件实际上是通过IClassFactory来创建的.

3.CoGetClassObject

要创建一个组件,首先要创建类厂本身.

   CoCreateInstance()用来创建与指定CLSID的组件,并返回指向组件某个接口的指针.
   与CoCreateInstance类似,用CoGetClassObject() 来创建与指定CLSID的类厂,并返回指向类厂某个接口的指针.

  函树定义如下:
 
  HRESULT __stdcall 用CoGetClassObject(

   const CLSID & clsid,
   DWORD  dwClsContext,    //server context
   COSERVERINFO *pServerInfo,  //Resevred for DCOM
   const IID &iid,
   void ** ppv
);

 客户用 CoCreateInstanc 所返回的指针来创建所需的组件,这个指针通常是一个IClassFactory指针.
 
 3.IClassFactory
 
 类厂所支持的用于创建组件的标准接口是 IClassFactory.大部分组件可以通过它来创建.
 声明如下:
  
 interface IClassFactory :IUnknown
 {
  HRESULT stdcall  CreateInstace(IUnknown * pUnknownOuter,
                  const IID &iid,
                  void **ppv);
  HRESULT stdcall LockServer(bool bLock);
  };
  
 4.为什么要用用CoGetClassObject

大多数情况下使用 CoCreateInstanc 创建组件，而不使用CoGetClassObject。但是在以下两种情况  下应使用CoGetClassObject而不使用 CoCreateInstanc 。
1、若想用不同于 IClassFactory 的某个创建接口来创建组件，则必须使用CoGetClassObject。
2、若需要创建同一组件的多个不同实例，使用CoGetClassObject可以取得较高效率。因为这样只需相应组件的类厂一次，而CoCreateInstanc 需要为每个实例分别创建并释放相应的类厂。
另外，CoGetClassObject可以对组件的创建过程进行更多的控制。

1,创建一个组件最简单的方法:用 CoCreateInstanc函数.因此CoCreateInstanc也是创建组件用的最多的一种方法.但其灵活性有限,不能满足所有组件的需求. 这就是为什么要引入类厂.

 所有组件都是用类厂创建的.  CoCreateInstanc也是按照一般方法通过类厂来创建组件的.

2. CoCreateInstanc

com库中包含一个创建组件的名为CoCreateInstanc的函数.

定义如下:

HRESULT __stdcall CoCreateInstanc(

   const CLSID & clsid,
   IUnknown * pIUnknown,   //outer component
   DWORD  dwClsContext,    //server context
   const IID &iid,
   void ** ppv
);

看以看到有四个输入参数一个输出参数.
第一个待创建组件的CLSID.
第二个是用来聚合组件的.
第三个是用来限定所创建组件的执行上下文.
第四个是组件待使用的接口的IID;
CoCreateInstanc将在最后一个参数中返回此接口指针.
将一个IID 传给CoCreateInstanc,客户将无需在创建组件后再调用QueryInterface;

3.CoCreateInstanc的使用

  IX *pIX = NULL;
  HRESULT  hr = CoCreateInstanc(CLSID_component1,
                                NULL,
                                CLSCTX_INPROC_SERVER,
                                IID_IX,
                                (void **)&pIX);

  if(SUCCEEDED(hr))
 {
  pIX->Fx();
  pIX->Release();
  }

该例子创建了一个由CLSID_component1标志的组件.
此处不需要聚合组件,因此第二个参数之NULL;
我们用IID_IX来表示希望得到接口IIX的指针,CoCreateInstanc将把此指针返回在pIX变量中,若成功返回则可用该接口.Release()表示对接口和组件的使用已经完成.

类上下文

CoCreateInstanc的第三个参数可以控制所创建的组件是在客户创建的进程中运行,还是在不同进程中.或者在另外一台机器上.

该参数可以由一下几个值组合:

CLSCTX_INPROC_SERVER,
CLSCTX_INPROC_HANDLER,
CLSCTX_LOCAL_SERVER,
CLSCTX_REMOTE_SERVER;
客户可以在三种不同上下文中使用某个组件: 进程中,本地,远程.

HRESULT  __stdcall QueryInterface(const IID&iid,void **ppv);

iid：标志客户所需的接口。是”一个接口标志符“结构（IID）。
ppv：QueryInterface用来存放所请求接口的地址。

返回值：可以返回S_OK 或 E_NOINTERFACE应该用SUCEEDED或者FAILED宏验证是否成功。

使用方法：

假如知道一个指向IUnknown接口的指针pI，传给它一个接口标志符即可

例如：

void Foo(IUnknown * pI)
{
    IX * pIX = NULL;

    HRESULT hr = pI->QueryInterface(IID_IX,(void **)pIX);

    if(SUCCEEDED(hr))
    {
      pIX->FX();
     }
}

//QueryInterface的实现。

HRESULT _stdcall  CA::QueryInterface(const    IID&iid,void **ppv)
{
    if(iid == IID_IUnknown)
    {
      *ppv = static_cast<IX *>(this);
    }
    else  if(iid == IID_IX)
    {
      *ppv = static_cast<IX *>(this);
    }
    else  if(iid == IID_IY)
    {
      *ppv = static_cast<IY *>(this);
    }
    else  if(iid == IID_IUnknown)
    {
      *ppv = NULL;
      return E_NOINTERFACE;
    }

    static_cast <IUnknown *> (* ppv)->AddRef();
    retru S_OK;

}

多重继承及类型转换。

通常将一种类型的指针转换为另一种类型并不会改变它的值。为了支持多重继承，某些情况下，C++必须改变类指针的值。
假如一个类定义如下：

class CA: public IX,public IY{...};

由于CA同时继承了IX，IY因此可以使用IX或IY指针的地方均可以使用指向CA的指针。

void foo(IX* pIX);
void bar(IY* pIY);
int main()
{
 CA* pA = new CA;
 foo(pA);
 bar(pA);
 delete pA;
 return 0;
}

foo需要一个指向合法的IX的虚拟函数表的指针；
bar需要一个指向合法的IY的虚拟函数表的指针；
当然IX和IY的虚拟函数表的内容是不一样的。因此将一个IX vtbl传给bar时，此函数是不能正常工作的。
因此编译器将同一指针传给foo和bar是不可能的，它必须对CA的指针进行修改以便他指向一个合适的vtbl指针。
下图显示了CA对象的内存结构。

class IX
{
public:
 virtual void Fx1() = 0 ;
 virtual void Fx2() = 0 ;
}; 
class IY
{
public:
 virtual void Fy1() = 0 ;
 virtual void Fy2() = 0 ;
}; 
class CA: public IX,
   public IY
{
public:
 virtual void Fx1()
 {
   cout<<"Fx1()"< }
 virtual void Fx2()
 {
   cout<<"Fx2()"< }
 virtual void Fy1()
 {
   cout<<"Fy1()"< }
 virtual void Fy2()
 {
   cout<<"Fy2()"< }
}

相关概念：纯抽象基类：指包含纯抽象函数的基类。
                   纯虚构函数：用 =0 标记的虚构函数。
多重继承：指一个类直接继承一个以上的基类。
对纯虚函数的继承称为接口继承。
IX和IY并不是真正意义上的COM接口，为使之成为COM接口，它必须继承一个名为IUnknown的接口。

/**////interface.h 
#include "iostream.h"

#include "objbase.h"


void trace(const char * pMsg){cout<<pMsg<<endl;}

interface IX
{
 virtual void __stdcall Fx1() = 0;
 virtual void __stdcall Fx2() = 0;
};
interface IY
{
 virtual void __stdcall Fy1() = 0;
 virtual void __stdcall Fy2() = 0;
};

class CA: public IX,
       public IY
{
public:
 virtual void __stdcall Fx1(){cout<<"CA::Fx1()"<<endl;}
 virtual void __stdcall Fx2(){cout<<"CA::Fx2()"<<endl;}

 virtual void __stdcall Fy1(){cout<<"CA::Fy1()"<<endl;}
 virtual void __stdcall Fy2(){cout<<"CA::Fy2()"<<endl;}
};
// com_1.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "IFace.h"

int main(int argc, char* argv[])
{
 trace("Create an instance of the componet!");
 CA * pA = new CA;
 IX * pIX = pA;
 trace("use the ix interface!");
 pIX->Fx1();
 pIX->Fx2();

 IY * pIY = pA;
 trace("use the iy interface!");
 pIY->Fy1();
 pIY->Fy2();
 pA->Fx1();
 trace("delete the componet!");
 delete pA;
 printf("Hello World!\n");
 return 0;
}

      
运行结果如下：


总结：
1、COM接口在c++中用纯抽象基类实现。
2、一个COM组件可以提供多个接口。
3、一个C++类可以使用多继承实现一个提供多个接口的组件。
在com中，对一个组件的访问只能通过函数，而决不能直接通过变量。