com组件类厂

实际在创建组件过程中，CoCreateInstance(CLSID,IUNKNOWN*,context,const IID&,void**)调用DllGetClassObject(const CLSID&,const IID&,void**)，该函数返回类厂组件，类厂组件调用组件接口CreateInstance(IUNKNOWN*, const IID&, void**)返回对应组件。

//CoCreateInstance示例

HRESULT CoCreateInstance(const CLSID& clsid, IUnKnown* pOuterUnKnown, DWORD dwcontext,const IID& iid, void** pv)

{

         HRESULT hr = DllGetClassObject(clsid, IID_IFACTOYR, pv);

         if(SUCCEED(hr))

         {

                   hr = static_cast<IFactory*>(*pv)->CreateInstance(pOuterUnKnown,iid,pv);

                   static_cast<IFactory*>(*pv)->Release();

                   return hr;

         }

         else

                   return E_FAIL;

}


//产生类厂组件函数，由组件程序员实现

STDAPI DllGetClassObject(const CLSID& clsid, const IID& iid, void**pv)

{

         if(clsid != CLSID_COMPONENT1)

                   return CLASS_E_CLASSNOTAVAILABLE;

         IFactory* pFactory= new CAIFactory;

         if(NULL != pFactory)

         {

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

                   if(SUCCEED(hr))

                   {

                            pFactory->Release();

                            return S_OK;

                   }

                   else

                   {

                            pFactory->Release();

                            return E_FAIL;

                   }

         }

         else

         {

                   return E_OUTOFMEMORY;

         }

}

struct IFactory:public IUnknown//类厂接口，用于创建对应的组件

{

         IFactory() = 0;

         virtual HRESULT CreateInstance(IUnknown* pOutUnknown,const IID& iid, void** pv) = 0;

         ~IFactory() = 0;

};


//具体的类厂由组件程序员实现

struct CAIFactory:public IFactory{

         HRESULT QueryInterface(const IID& iid, void** pv)

         {

                   if(iid == IID_IUnKnown)

                   {

                            *pv = static_cast<IUnknown*>(this);

                            return S_OK;

                   }

                   else if(iid == IID_IFactory)

                   {

                            *pv = static_cast<IFactory*>(this);

                            return S_OK;

                   }

                   else if(iid == IID_CAIFactory)

                   {

                            *pv = static_cast<CAIFactory*>(this);

                            return S_OK;

                   }

                   else

                   {

                            *pv = NULL;

                            return E_FAIL;

                   }

                   static_cast<IUnknown*>(*pv)->AddRef();

         }

        

         void AddRef(){++m_refcnt;}

         void Release()

         {

                   --m_refcnt;

                   if(m_refcnt == 0)

                            delete this;

         }

        

         HRESULT CreateInstance(IUnknown* pOuterKnown, const IID& iid, void** pv)

         {

                   CA* pCA = new CA;

                   if(NULL != pCA)

                   {

                            HRESULT hr = pCA->QueryInterface(iid,pv);

                            if(SUCCEED(hr))

                            {

                                     pCA->Release();

                                     return S_OK;

                            }

                            else

                            {

                                     pCA->Release();

                                     return E_FAIL;

                            }

                   }

                   else

                   {

                            return E_FAIL;

                   }

         }

        

         CAIFactory():m_refcnt(0){}

         ~CAIFactory(){}

        

private:

         int m_refcnt;

};