COM Fundamentals and Basic Programming Introduction

What is COM

// COM interface definition in IDL (Interface Definition Language)
[
   object,
   uuid(12345678-1234-1234-1234-123456789ABC),
   pointer_default(unique)
]
interface IPhoneBook : IUnknown
{
   HRESULT AddEntry([in] BSTR name, [in] BSTR number);
   HRESULT GetEntry([in] BSTR name, [out, retval] BSTR* number);
   HRESULT RemoveEntry([in] BSTR name);
   HRESULT GetCount([out, retval] long* count);
};

// COM client usage in C++
void use_phone_book() {
   IPhoneBook* phoneBook = nullptr;
   
   // Create COM object instance
   HRESULT hr = CoCreateInstance(
      CLSID_PhoneBook,
      nullptr,
      CLSCTX_INPROC_SERVER,
      IID_IPhoneBook,
      (void**)&phoneBook
   );
   
   if (SUCCEEDED(hr)) {
      // Use interface methods
      phoneBook->AddEntry(L"Alice", L"555-1234");
      
      BSTR number = nullptr;
      phoneBook->GetEntry(L"Alice", &number);
      
      // Release when done
      phoneBook->Release();
      SysFreeString(number);
   }
}

COM Architecture: Objects, Interfaces, and Servers

// Conceptual COM object structure
class com_phone_book : public IPhoneBook {
private:
   ULONG ref_count;  // Reference counting for lifetime management
   std::map<std::wstring, std::wstring> entries;

public:
   // IUnknown methods (required for all COM interfaces)
   STDMETHODIMP QueryInterface(REFIID riid, void** ppv);
   STDMETHODIMP_(ULONG) AddRef();
   STDMETHODIMP_(ULONG) Release();

   // IPhoneBook methods
   STDMETHODIMP AddEntry(BSTR name, BSTR number);
   STDMETHODIMP GetEntry(BSTR name, BSTR* number);
   STDMETHODIMP RemoveEntry(BSTR name);
   STDMETHODIMP GetCount(long* count);
};

// AddRef implementation - reference counting
STDMETHODIMP_(ULONG) com_phone_book::AddRef() {
   return InterlockedIncrement(&ref_count);
}

// Release implementation - destroys when count reaches zero
STDMETHODIMP_(ULONG) com_phone_book::Release() {
   ULONG count = InterlockedDecrement(&ref_count);
   if (count == 0) {
      delete this;
   }
   return count;
}

IUnknown: The Foundation Interface

// IUnknown interface definition
interface IUnknown {
   // Query for additional interfaces
   HRESULT QueryInterface(REFIID riid, void** ppvObject);
   
   // Reference counting
   ULONG AddRef();
   ULONG Release();
};

// QueryInterface implementation pattern
STDMETHODIMP com_phone_book::QueryInterface(REFIID riid, void** ppv) {
   if (riid == IID_IUnknown) {
      *ppv = static_cast<IUnknown*>(this);
   }
   else if (riid == IID_IPhoneBook) {
      *ppv = static_cast<IPhoneBook*>(this);
   }
   else {
      *ppv = nullptr;
      return E_NOINTERFACE;
   }
   
   AddRef();  // Client receives a new reference
   return S_OK;
}

// Proper COM client usage with reference counting
void demonstrate_reference_counting() {
   IPhoneBook* pb1 = nullptr;
   
   // Create increases ref count to 1
   CoCreateInstance(CLSID_PhoneBook, nullptr, CLSCTX_ALL,
                    IID_IPhoneBook, (void**)&pb1);
   
   IPhoneBook* pb2 = pb1;
   pb2->AddRef();  // Explicit AddRef for second pointer
   
   // Both pointers must Release
   pb1->Release();  // Count: 2 → 1
   pb2->Release();  // Count: 1 → 0, object destroyed
}

Marshaling and Cross-Process Communication

Interface Definition Language (IDL) and MIDL

// Example IDL file: PhoneBook.idl
import "oaidl.idl";
import "ocidl.idl";

[
   uuid(AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE),
   version(1.0),
   helpstring("PhoneBook Type Library")
]
library PhoneBookLib
{
   importlib("stdole2.tlb");

   [
      object,
      uuid(12345678-1234-1234-1234-123456789ABC),
      dual,
      helpstring("IPhoneBook Interface"),
      pointer_default(unique)
   ]
   interface IPhoneBook : IDispatch
   {
      [id(1), helpstring("Add phone book entry")]
      HRESULT AddEntry([in] BSTR name, [in] BSTR number);
      
      [id(2), helpstring("Get phone number for name")]
      HRESULT GetEntry([in] BSTR name, [out, retval] BSTR* number);
      
      [id(3), helpstring("Remove entry")]
      HRESULT RemoveEntry([in] BSTR name);
      
      [id(4), helpstring("Get total entries")]
      HRESULT GetCount([out, retval] long* count);
   };

   [
      uuid(87654321-4321-4321-4321-210987654321),
      helpstring("PhoneBook Class")
   ]
   coclass PhoneBook
   {
      [default] interface IPhoneBook;
   };
};

// MIDL generates C++ header from this IDL:
// - Interface declarations
// - GUID definitions (IID_IPhoneBook, CLSID_PhoneBook)
// - Proxy/stub code for marshaling
// - Type library (.tlb) for runtime type information

Active Template Library (ATL)

// ATL-based COM object implementation
#include <atlbase.h>
#include <atlcom.h>

class ATL_NO_VTABLE phone_book_atl :
   public CComObjectRootEx<CComSingleThreadModel>,
   public CComCoClass<phone_book_atl, &CLSID_PhoneBook>,
   public IPhoneBook
{
private:
   std::map<CComBSTR, CComBSTR> entries;

public:
   phone_book_atl() {}

   // ATL COM map - declares supported interfaces
   BEGIN_COM_MAP(phone_book_atl)
      COM_INTERFACE_ENTRY(IPhoneBook)
   END_COM_MAP()

   // ATL handles IUnknown automatically via templates
   
   // Implement IPhoneBook methods
   STDMETHOD(AddEntry)(BSTR name, BSTR number) {
      entries[name] = number;
      return S_OK;
   }

   STDMETHOD(GetEntry)(BSTR name, BSTR* number) {
      auto it = entries.find(name);
      if (it == entries.end()) return E_INVALIDARG;
      
      *number = it->second.Copy();
      return S_OK;
   }

   STDMETHOD(RemoveEntry)(BSTR name) {
      entries.erase(name);
      return S_OK;
   }

   STDMETHOD(GetCount)(long* count) {
      *count = static_cast<long>(entries.size());
      return S_OK;
   }
};

// Registry script for COM registration
OBJECT_ENTRY_AUTO(__uuidof(PhoneBook), phone_book_atl)

Distributed COM (DCOM)

COM+ and the Evolution Beyond COM

The Transition to .NET and Modern Development

Why Study COM Today

Course Structure and Learning Objectives

Prerequisites and Expectations

Course Series Context

Conclusion