ArcGIS Engine Developer Guide

VISUAL C++
Grimes, Richard, Reilly Stockton, Alex Stockton, and Julian Templeman. Beginning
ATL 3 COM Programming. Chicago: Wrox Press Inc., 1999.
King, Brad, and George Shepherd. Inside ATL. Redmond, WA: Microsoft Press,
1999.
Rector, Brent, Chris Sells, and Jim Springfield. ATL Internals. Reading, MA:
Addison–Wesley, 1999.
SMART TYPES
Smart types are objects that behave as types. They are C++ class implementations
that encapsulate a data type, wrapping it with operators and functions that make
working with the underlying type easier and less error prone. When these smart
types encapsulate an interface pointer, they are referred to as smart pointers. Smart
pointers work with the IUnknown interface to ensure that resource allocation and
deallocation are correctly managed. They accomplish this by various functions,
construct and destruct methods, and overloaded operators. There are numerous
smart types available to the C++ programmer. The two main smart types covered
here are Direct-To-COM and Active Template Library.
Smart types can make the task of working with COM interfaces and data types
easier, since many of the API calls are moved into a class implementation; however,
they must be used with caution and never without a clear understanding of
how they are interacting with the encapsulated data type.
Direct-To-COM smart types
The smart type classes supplied with DTC are known as the Compiler COM
Support Classes and consist of:
• _com_error—This class represents an exception condition in one of the COM
support classes. This object encapsulates the HRESULT and the IErrorInfo
COM exception objects.
• _com_ptr_t—This class encapsulates a COM interface pointer. See below for
common uses.
• _bstr_t—This class encapsulates the BSTR data type. The functions and operators
on this class are not as rich as the ATL CComBSTR smart type; hence, this
is not normally used.
• _variant_t—This class encapsulates the VARIANT data type. The functions
and operators on this class are not as rich as the ATL CComVariant smart type;
hence, this is not normally used.
To define a smart pointer for an interface, you can use the macro
_COM_SMARTPTR_TYPEDEF like this:
_COM_SMARTPTR_TYPEDEF(IFoo, __uuidof(IFoo));
The compiler expands this as follows:
typedef _com_ptr_t< _com_IIID > IFooPtr;
Once declared, it is simply a matter of declaring a variable as the type of the
interface and appending Ptr to the end of the interface. Below are some common
uses of this smart pointer that you will see in the numerous C++ samples.
// Get a CLSID GUID constant.
110 • ArcGIS Engine Developer Guide