ATL Internals
- Published Mar 31, 1999 by Addison-Wesley Professional. Part of the Addison-Wesley Object Technology Series series.
Book
- This product currently is not for sale.
Description
- Copyright 1999
- Dimensions: 7-3/8x9-1/4
- Pages: 656
- Edition: 1st
- Book
- ISBN-10: 0-201-69589-8
- ISBN-13: 978-0-201-69589-2
"This book is the definitive reference for ATL programmers. The chapter on CComObject is worth the price alone."--Don Box, COM guy, DevelopMentor
"Brent and Chris are always technically accurate and present the information in a well written, easy to understand manner... I bought it and I'm the ATL Development Lead!"--Christian Beaumont, ATL Development Lead, Microsoft Corporation
The Active Template Library (ATL) is a set of small, efficient, and flexible classes that facilitate the creation of interoperable COM components. Written for experienced COM and Visual C++ programmers, this book provides in-depth coverage of ATL's inner workings. It offers insight into the rationale behind ATL design, explains its architectural underpinnings, shows how ATL maps to COM, and describes important implementation details.
With coverage current through ATL version 3.0, ATL Internals includes an overview of the Wizards but then goes well beyond the basics. The authors provide the detailed information needed to utilize ATL to its greatest advantage and work around its shortcomings. You will find detailed coverage of such topics as:
- ATL Smart Types, such as CComPtr, CComVariant, and CComBSTR
- Objects in ATL, covering COM object responsibilities and ATL threading model support
- Servers in ATL, including ATL's class object implementations, managing server lifetime, self-registration, and server build optimizations
- Interface maps, focusing on the techniques C++ programmers can use to implement COM interfaces and how ATL supports these techniques
- Persistence and connection points
- Enumeration, covering both pre-calculated and dynamic data sets, and enumerating over an STL container
- ATL windowing classes
- Controls and Control Containment
If you want to optimize ATL by learning effective techniques that reduce the time you spend writing boilerplate COM code, there is no better resource than this book.
0201695898B04062001
Downloads
Source Code
Click below for Source Code related to this title:
ActiveXoutline.html
atlcode.zip
Sample Content
Table of Contents
Foreword.
Preface.
1. Hello, ATL.
What Is ATL?
Creating a COM Server.
Inserting a COM Class.
Adding Properties and Methods.
Implementing Additional Interfaces.
Support for Scripting.
Adding Persistence.
Adding and Firing Events.
Using a Window.
Implementing Component Categories.
Adding a User Interface.
Hosting a Control.
Summary.
2. ATL Smart Types: Strings, BSTRs, VARIANTs, and Interface Pointers.
String Data Types, Conversion Macros, and Helper Functions.
The CComBSTR Smart BSTR Class.
The CComBSTR Class.
The ComVariant Smart VARIANT Class.
The CComPtr, CComQIPtr, and CComDispatchDriver Smart Pointer Classes.
Summary.
3. Objects in ATL.
Recall: COM Apartments.
Implementing IUnknown.
The Layers of ATL.
Threading Model Support.
The Core of IUnknown.
Your Class.
CComObject et al.
ATL Creators.
Debugging.
Summary.
4. COM Servers.
A Review of COM Servers.
The Object Map and the CComModule Class.
The Object Map.
Methods Required of an Object Map Class.
The CComModule Class.
CComCoClass Revisited.
Server Optimization Compilation Options.
Summary.
5. Interface Maps.
Recall: COM Identity.
Table-Driven QueryInterface.
Multiple Inheritance.
Tear-off Interfaces.
Aggregation: The Controlling Outer.
Interface Map Tricks.
Summary.
6. Persistence in ATL.
A Review of COM Persistence.
ATL Persistence Implementation Classes.
The Property Map.
The Persistence Implementations.
Additional Persistence Implementations.
Adding Marshal-by-Value Semantics Using Persistence.
Summary.
7. Collections and Enumerators.
COM Collection and Enumeration Interfaces.
Enumerating Arrays.
Enumerating STL Collections.
Collections.
STL Collections of ATL Data Types.
Simple Collections.
Object Models.
Summary.
8. Connection Points.
A Review of Connection Points.
Creating an ATL-Based Connectable Object.
Creating an Object That Is an Event Recipient.
How It All Works: The Messy Implementation Details.
Summary.
9. Windowing.
The Structure of a Windows Application.
CWindow.
CWindowImpl.
CDialogImpl.
Windows Control Wrappers.
CContainedWindow.
Summary.
10. ActiveX Controls.
A Review of ActiveX Controls.
The BullsEye Control Requirements.
Creating the Initial Control Using the ATL Wizard.
The Initial BullsEye Source Files.
Developing the BullsEye Control Step by Step.
Summary.
11. Control Containment.
How Controls Are Contained.
Basic Control Containment.
Hosting a Control in a Dialog.
Composite Controls.
HTML Controls.
ATL's Control Containment Limitations.
Summary.
Appendix A: C++ Templates by Example.
The Need for Templates.
Template Basics.
A Different Kind of Polymorphism.
Function Templates.
Member Function Templates.
Summary.
Appendix B: ATL Classes and Headers.
Index. 0201695898T04062001
Preface
C is a framework for generating assembly language code (ASM). Most ASM programmers shifting to C spent a lot of time examining and replacing the compiler-generated code because they didn't trust the compiler to create correct code. As time went on and C compilers got better, ASM programmers gradually learned to trust the compiler to generate not only correct code, but also efficient code. Of course, talented C programmers never forget that the compiler is generating ASM. They know that they can still reach into selected areas and dictate the generated code when their needs exceed the capabilities of the language.
Microsoft's Active Template Library (ATL) is a framework for generating C++/COM code. Most C++ programmers shifting to ATL seem to fear examining, let alone replacing, ATL-generated code. They don't trust ATL any more than ASM programmers trusted their C compilers, because the source for ATL is fairly inscrutable to the casual observer. However, ATL is performing the same services for the C++/COM programmer that the C compiler performed for ASM programmers, namely, providing a simpler way to generate boilerplate code correctly and efficiently. Of course, talented ATL programmers never forget that ATL is generating C++/COM code. They know that they can still reach into selected areas and dictate the generated code when their needs exceed the capabilities of ATL. Our goal in writing this book is to turn you into an ATL programmer, unafraid to reach into it and bend it to your will.
This book is for the C++/COM programmer shifting to ATL 3.0, as provided with Visual C++ 6.0. Because ATL was built with a set of assumptions, to be an effective ATL programmer you need to understand not only how ATL is built but also why. Of course, to understand the why of ATL, you'll have to understand the environment in which ATL was developed, that is, COM. Instead of attempting to compress all required COM knowledge into one or two chapters, this book assumes you already know COM and shows you the design, usage, and internals of ATL. Don Box's Essential COM (Addison-Wesley, 1998) is a good source of COM knowledge, if you'd like to brush up before diving into ATL.
With the exception of the first chapter, this book was arranged from the lowest levels of ATL to the highest, each chapter building on knowledge in previous chapters. The first chapter is a brief overview of some of the more common uses for ATL, and the wizards (if they exist) that aid in these uses. Whenever things get too detailed in the first chapter, however, we refer you to a subsequent chapter that will provide more in-depth coverage. Chapters 2 through 5 present the core of ATL. Chapter 2 covers the ATL smart types, such as CComPtr, CComQIPtr, CComBSTR, and CComVariant. Chapter 3 discusses how objects are implemented in ATL, concentrating on the great range of choices you have when implementing IUnknown. Chapter 4 discusses the glue code required to expose COM objects from COM servers. Chapter 5 delves into the implementation of IUnknown again, this time concentrating on how to implement QueryInterface, showing techniques such as tear-off interfaces and aggregation. Chapters 6, 7, and 8 discuss canned interface implementations that ATL provides to support object persistence, connection points, and COM collections and enumerators, respectively. These services can be used by components that may or may not provide their own user interface. Chapters 9, 10, and 11, on the other hand, concentrate on building both standalone applications and user interface components. These chapters cover the ATL window classes, controls, and control containment, respectively. Because much of what makes the ATL source difficult to read is its advanced use of templates, Appendix A provides a set of examples meant to illustrate how templates are used and built. If you've seen ATL source code before and wondered why you can pass the name of a deriving class to a base class template, you may find Appendix A useful. Appendix B provides a list of the important ATL classes and the header files in which they are declared (and often implemented).
When writing these chapters, it became necessary not only to show diagrams and sample usage code, but also internal ATL implementation code. In fact, this book often becomes your personal tour guide through the ATL source code.
Because the ATL team didn't write their code to be published in book form, it was often necessary to reformat it or even to abbreviate it. Every effort has been made to retain the essence of the original code, but, as always, the ATL source code is the final arbiter. You might find Appendix B useful when tracking down the actual implementation.
If there are any errors in the sample source or in any part of this book, you may contact Brent Rector at http://www.wiseowl.com and Chris Sells at http://www.sellsbrothers.com. The source code used in this book is available at http://www.wiseowl.com/ATLInternals.htm.
The authors would like to thank all of the following for their contributions to this book. While it may have been possible to complete this book without them, it would have been a pale imitation of what we were able to achieve with their help. Chris would like to thank his wife, Melissa, and his boys, John and Tom, for sparing him the countless evenings and weekends to work on this project. Chris would also like to thank Brent Rector for letting him horn in on his book project.
Brent would like to thank his wife, Lisa, and his children, Carly and Sean, for delaying the delivery of this book significantly. If it weren't for them, he'd never leave the computer some days. Brent would like to thank Chris for his intelligence, patience, and general good looks.(1)
Brent and Chris would like to thank several folks together. Special thanks to Christian Beaumont, Jim Springfield, Walter Sullivan, and Mark Kramer for suffering our nagging questions and taking the time to answer them. More special thanks to Don Box for his MSJ ATL feature, which so heavily influenced the course and, in turn, this book. Thanks to the reviewers: Don Box, Keith Brown, Jon Flanders, Mike Francis, Kevin Jones, Stanley Lippman, Dharma Shukla, Jim Springfield, Jeff Stalls, Jaganathan Thangavelu, and Jason Whittington. Special thanks goes to Dharma for his especially thorough, and educational, reviews. Thanks to fellow DevelopMentor instructor Fritz Onion for his groundbreaking work delving into the depths of ATL control containment. Thanks to a former student, Valdan Vidakovic, for inspiring Chris to delve a bit more into the HTML control. Thanks to Tim Ewald, Jim Springfield, and Don Box for their help in developing the forwarding shims trick. Thanks to the members of the ATL and DCOM mailing lists, especially Don Box, Tim Ewald, Charlie Kindel, Valery Pryamikov, Mark Ryland, and Zane Thomas. And last, but not least, thanks to Addison-Wesley, especially J. Carter Shanklin and Krysia Bebick, for providing an environment in which we actually want to write (although not as quickly or as concisely as they might like).
(1) You only get one guess as to who wrote this sentence, and he doesn't have my initials or my good looks. BER
0201695898P04062001
More Information
Other Things You Might Like
