《COM技术内幕》笔记(二）

//AddRef和Release的实现
#include <iostream>
using namespace std;
#include <objbase.h>

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

// Forward references for GUIDs
extern const IID IID_IX ;
extern const IID IID_IY ;
extern const IID IID_IZ ;

// 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 ;
} ;


//
// Component
//
class CA : public IX,
           public IY
{
    // IUnknown 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 ;}

    // Interface IY implementation
    virtual void __stdcall Fy() { cout << "Fy" << endl ;}

public:
    // Constructor
    CA() : m_cRef(0) {}

    // Destructor
    ~CA() { trace("CA:     Destroy self.") ;}

private:
    long m_cRef;
} ;

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

ULONG __stdcall CA::AddRef()
{
    cout << "CA:     AddRef = " << m_cRef+1 << '.' << endl ;
    return InterlockedIncrement(&m_cRef) ;
}

ULONG __stdcall CA::Release() 
{
    cout << "CA:     Release = " << m_cRef-1 << '.' << endl ;

    if (InterlockedDecrement(&m_cRef) == 0)
    {
        delete this ;
        return 0 ;
    }
    return m_cRef ;
}

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

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

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

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

//
// Client
//
int main()
{
    HRESULT hr ;

    trace("Client: Get an IUnknown pointer.") ;
    IUnknown* pIUnknown = CreateInstance() ;


    trace("Client: Get interface IX.") ;

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

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


    trace("Client: Get interface IY.") ;

    IY* pIY = NULL ;
    hr = pIUnknown->QueryInterface(IID_IY, (void**)&pIY) ;
    if (SUCCEEDED(hr))
    {
        trace("Client: Succeeded getting IY.") ;
        pIY->Fy() ;          // Use interface IY.
        pIY->Release() ;
    }


    trace("Client: Ask for an unsupported interface.") ;

    IZ* pIZ = NULL ;
    hr = pIUnknown->QueryInterface(IID_IZ, (void**)&pIZ) ;
    if (SUCCEEDED(hr))
    {
        trace("Client: Succeeded in getting interface IZ.") ;
        pIZ->Fz() ;
        pIZ->Release() ;
    }
    else
    {
        trace("Client: Could not get interface IZ.") ;
    }


    trace("Client: Release IUnknown interface.") ;
    pIUnknown->Release() ;
    system("pause");
    return 0;
}