COM客户调用解析及源代码

//
// Client1.cpp
// To compile, use: cl Client1.cpp Create.cpp GUIDs.cpp UUID.lib
//

#include <iostream.h>
#include <objbase.h>

#include "Iface.h"
#include "Create.h"

void trace(const char* msg) { cout << "Client 1:\t" << msg << endl ;}

//
// Client1
//

int main()
{
    HRESULT hr ;

    // Get the name of the component to use.

    char name[40] ;
    cout << "Enter the filename of a component to use [Cmpnt?.dll]: " ;
    cin >> name ;
    cout << endl ;

    // Create component by calling the CreateInstance function in the DLL.

    trace("Get an IUnknown pointer.") ;
    IUnknown* pIUnknown = CallCreateInstance(name) ;
    if (pIUnknown == NULL)
    {
        trace("CallCreateInstance Failed.") ;
        return 1 ;
    }

    trace("Get interface IX.") ;

    IX* pIX ;
    hr = pIUnknown->QueryInterface(IID_IX, (void**)&pIX) ;

    if (SUCCEEDED(hr))
    {
        trace("Succeeded getting IX.") ;
        pIX->Fx() ; // Use interface IX.

        pIX->Release() ;
    }
    else
    {
        trace("Could not get interface IX.") ;
    }

    trace("Release IUnknown interface.") ;
    pIUnknown->Release() ;

    return 0 ;
}


//
//    Create.cpp
//

#include <iostream.h>
#include <unknwn.h>
#include "Create.h"

typedef IUnknown* (*CREATEFUNCPTR)();

IUnknown * CallCreateInstance(char * name){

    //Load Dll into proccess

    HINSTANCE hComponent = ::LoadLibrary(name) ;
    if(hComponent == NULL){
        cout<<"CallCreateInstance: \t Error:Cannot load component."<<endl;
        return NULL;
    }
    
    //Get address for CreateInstance function.

    CREATEFUNCPTR CreateInstance = (CREATEFUNCPTR)::GetProcAddress(hComponent,"CreateInstance");
    if(CreateInstance == NULL){
        cout<<"CallCreateInstance: \t Error:"<<"Cannot find CreateInstance function."<<endl;
        return NULL;
    }

    return CreateInstance();

}

//
// Create.h
//
IUnknown* CallCreateInstance(char* name) ;


//

// GUIDs.cpp - Interface IDs
//
#include <objbase.h>

extern "C"
{
    // {32bb8320-b41b-11cf-a6bb-0080c7b2d682}

    extern const IID IID_IX =
        {0x32bb8320, 0xb41b, 0x11cf,
        {0xa6, 0xbb, 0x0, 0x80, 0xc7, 0xb2, 0xd6, 0x82}} ;

    // {32bb8321-b41b-11cf-a6bb-0080c7b2d682}

    extern const IID IID_IY =
        {0x32bb8321, 0xb41b, 0x11cf,
        {0xa6, 0xbb, 0x0, 0x80, 0xc7, 0xb2, 0xd6, 0x82}} ;

    // {32bb8322-b41b-11cf-a6bb-0080c7b2d682}

    extern const IID IID_IZ =
        {0x32bb8322, 0xb41b, 0x11cf,
        {0xa6, 0xbb, 0x0, 0x80, 0xc7, 0xb2, 0xd6, 0x82}} ;
    // The extern is required to allocate memory for C++ constants.
}

//
// Iface.h
//

// Interfaces
interface IX : IUnknown{
    virtual void __stdcall Fx() = 0 ;
} ;

interface IY : IUnknown{
    virtual void __stdcall Fy() = 0 ;
} ;

interface IZ : IUnknown{
    virtual void __stdcall Fz() = 0 ;
} ;

// Forward references for GUIDs
extern "C"{
    extern const IID IID_IX ;
    extern const IID IID_IY ;
    extern const IID IID_IZ ;
}


//
//Cmpnt1.DEF
//
LIBRARY        CMPNT1.dll
DESCRIPTION    '(C)1996-1997 Dale E.Rogerson'
EXPORTS
        CreateInstance @1 PRIVATE

//
// GUIDs.cpp - Interface IDs
//
#include <objbase.h>

extern "C" {
    // {32bb8320-b41b-11cf-a6bb-0080c7b2d682}
    extern const IID IID_IX =
        {0x32bb8320, 0xb41b, 0x11cf,
        {0xa6, 0xbb, 0x0, 0x80, 0xc7, 0xb2, 0xd6, 0x82}} ;

    // {32bb8321-b41b-11cf-a6bb-0080c7b2d682}
    extern const IID IID_IY =
        {0x32bb8321, 0xb41b, 0x11cf,
        {0xa6, 0xbb, 0x0, 0x80, 0xc7, 0xb2, 0xd6, 0x82}} ;

    // {32bb8322-b41b-11cf-a6bb-0080c7b2d682}
    extern const IID IID_IZ =
        {0x32bb8322, 0xb41b, 0x11cf,
        {0xa6, 0xbb, 0x0, 0x80, 0xc7, 0xb2, 0xd6, 0x82}} ;

    // The extern is required to allocate memory for C++ constants.
}


//CMPNT1.CPP
//
//Cmpnt1.cpp
//To compile, use cl /LD Cmpnt1.cpp GUIDs.cpp UUID.lib Cmpnt1.def
//
#include <iostream.h>
#include <objbase.h>
#include "Iface.h"

void trace(const char * msg ) {cout<<"Component 1: \t"<<msg<<endl;}

//
//Component
//

class CA: public IX{
    //IUnknow implementation

    virtual HRESULT __stdcall QueryInterface(const IID& iid ,void** ppv);
    virtual ULONG __stdcall AddRef();
    virtual ULONG __stdcall Release();

    //Interface IX implementation

    virtual void __stdcall Fx() { cout<<"Fx"<<endl; }

public:
    //Constructor
    CA() : m_cRef(0) {}
    
    //Destructor
    ~CA() {trace("Destroy self.");}

private:
    long m_cRef;
};

HRESULT __stdcall CA::QueryInterface(const IID & iid ,void ** ppv){
    if(iid == IID_IUnknown){
        trace("Return pointer to IUnknown.");
        *ppv = static_cast<IX*>(this);
    }
    else{
        if(iid == IID_IX){
            trace("Return pointer to IX.");
            *ppv = static_cast<IX*>(this);
        }
        else{
            trace("Interface not supported.");
            * ppv = NULL;
            return E_NOINTERFACE;
        }
        reinterpret_cast<IUnknown*>(*ppv)->AddRef();
        return S_OK;
    }
}

ULONG __stdcall CA::AddRef(){
    return InterlockedIncrement(&m_cRef);
}
ULONG __stdcall CA::Release(){
    if(InterlockedDecrement(&m_cRef) == 0){
        delete this;
        return 0;
    }
    return m_cRef;
}

//
//Creation function
//
extern "C" IUnknown * CreateInstance(){
    IUnknown * pI = static_cast<IX*>(new CA);
    pI->AddRef();
    return pI;
}