A single Component Object Model (COM) component is not very useful in isolation. To enable communication between objects, components include interfaces. An interface is a class that defines one or more methods (along with their associated parameters). As a naming convention, every COM interface is prefixed with "I". For example, as shown in Figure 2-12, a component may implement interfaces such as IUnknown, IReservation, and IAuction.

Every COM component implements the IUnknown interface, which is the foundation of all COM interfaces. In schematic representations, like Figure 2-12, the IUnknown interface is depicted as a lollipop extending from the top of the component. This interface makes the component self-describing, allowing a client to query whether a component supports specific interfaces. For example, a COM client needing an IReservation interface can query all components through their IUnknown interfaces with a request like, "Do you have an IReservation interface?" The first component that responds affirmatively handles the client's request.

In addition to IUnknown, a COM component typically implements one or more custom interfaces, such as IReservation or IAuction. In schematic diagrams (e.g., Figure 2-12), these interfaces are shown as lollipops extending from the left side of the component. For comparison, Visual Basic (VB) clients may use the IDispatch interface, which is similar to IUnknown but less efficient and tailored for VB-specific automation.

To make a component functional, it is compiled into machine code, creating a class. In COM, a class is an object-oriented term describing a collection of methods and attributes. Classes are defined using the Microsoft Interface Definition Language (MIDL) and assigned a globally unique identifier (GUID) to ensure uniqueness across systems.

Every COM interface inherits from IUnknown, which provides the foundation for interface navigation through its QueryInterface method. Interface navigation allows a client with a pointer to one interface of a COM object to acquire pointers to any other interfaces implemented by that object. The QueryInterface method is key to this process, with the following equivalent prototypes:

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

virtual HRESULT __stdcall QueryInterface
  (REFIID riid, VOID **ppv);

The second prototype, using REFIID, is more commonly used. REFIID is a macro defined as const IID &, and VOID is a Windows type alias for void. Since every COM interface implements QueryInterface, all interfaces support navigation to other interfaces within the same object. The QueryInterface method checks the riid (interface ID) parameter against the IIDs of all interfaces supported by the COM object. If a match is found, the ppv parameter is set to the requested interface pointer.

Consider the following example of a COM object, CMyComObject, which implements two interfaces, IMyComInterface and IYourComInterface:

class CMyComObject :
  public IMyComInterface,
  public IYourComInterface {
private:
  ULONG m_refcnt; // Reference count variable

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

  ULONG __stdcall AddRef();
  ULONG __stdcall Release();

  // Methods for IMyComInterface
  HRESULT __stdcall Fx1(char *buf);
  HRESULT __stdcall Fx2();

  // Methods for IYourComInterface
  HRESULT __stdcall Zx1(int ix);
};

The implementation of QueryInterface for CMyComObject is as follows: