About

Features

Description

Copyright 1997

Dimensions: 7-3/8x9-1/4

Pages: 480

Edition: 1st

Book

ISBN-10: 0-201-63358-2

ISBN-13: 978-0-201-63358-0

MFC Programming provides an in-depth introduction to writing 32-bit Windows applications using C++ and the Microsoft Foundation Class (MFC) library. The text builds from the ground up, first describing the Windows architecture and showing how MFC works with that architecture; next covering the document/view framework that simplifies the creation of industrial-strength programs; and finally illustrating advanced concepts like the usage of dynamic link libraries (DLL), creating Internet clients, and building form-based applications.

MFC Programming answers the hard questions by diving below the surface presented in the Reference Manual. For example, all types of controls are discussed, including the common controls, owner-draw controls using message reflection, and tool tips within a dialog. All of the common dialogs are described along with the the various methods of customization. Serialization is covered in depth, including serializing collections, reading and writing custom file formats, and using versionable schemas. Printing and previewing are described in detail, including printing of forms, scaling output to fit on a page, printing of headers and footers, and customization of the Page Setup dialog. Debugging strategies are explored, along with fixes to a few bugs encountered in MFC along the way.

Preface

Programming requires the ability to organize abstract concepts while being mindful of minute details. Details make the difference between success and failure in programming, but in attending to the details the overall structure can be forgotten. The Microsoft Foundation Classes (mfc) help with both the big picture and the small. They organize Windows objects and operations, bringing order to an otherwise chaotic landscape; and they embody much Windows programming protocol, handling the intricate dance that can cause a program to slip.

The Foundation Classes have their cost by adding additional, not always transparent, layers between a program and the operating system. While an mfc programmer does not need the depth of Windows understanding required by a raw api programmer, without some Windows knowledge, mfc comes to mean Much Frustration and Consternation. However, if you survive the initial learning curve and develop the skills required to make effective use of the class library, then mfc will surely help you write More Functional Code.

In teaching mfc, this text presents the whole picture, mfc and Windows. Along the way, it develops strategies for answering the myriad questions that arise in any real programming project. Always a source of amazement, you'll find yourself asking of mfc: How did it do that? Mastery of mfc programming requires that you understand the connective web between mfc and Windows to demystify the operation of mfc's application framework.

The form of this text has been heavily influenced by my experience teaching mfc to professional software developers. Although many concepts in mfc are easily grasped, some are complex and quite difficult. Accordingly, you'll find some topics treated lightly (the easy ones for you, I hope), while others are covered in great detail (such as the relationship between documents and views, and the process of serialization).

One thing this text does not try to do is replace the reference manual. I assume that you have easy access to reference material. One of the primary goals of this text is to help you over the conceptual hurdles to using mfc and give you the background information needed to understand the reference manual. Neither does the text attempt to teach usage of a particular compiler or development environment. All of the examples were created using Microsoft's Visual C++, but you'll find no screen shots of Developer's Studio. The operation of programming environments seems to change with the seasons, unlike the more durable programming concepts.

Mfc and Windows are moving targets. As a result, reference material sometimes lags reality, as will this book, in time. From time to time I'll expose the process that I went through to determine why various functions did not work as advertised in the manual. Understanding the overall organization of the class library will help you decipher the details.

What You Should Already Know

Despite the ability of some tools to generate a working Windows program from just a few clicks of the mouse, successful programming using mfc requires expertise in several areas of computing. I assume that you are competent programming in C++ and are at least familiar with Windows as a user. Competency in C++ entails knowing the language syntax, the object-oriented programming paradigm, and fundamental ideas of data structure and control flow. Although the text does not assume Windows programming knowledge, that knowledge certainly helps. Don't be fooled into thinking that you can ignore the Windows api by using mfc.

Organization of this Book

This text presents mfc from the ground up. It has three major parts. The first part looks toward the operating system, concentrating on Windows concepts. It presents the components of nearly every Windows program such as menus, dialogs, text, and graphics. Each chapter in this part has a companion program that illustrates the concepts expressed in the chapter.

The second part looks at the high-level code that drives many mfc applications. Mfc's application framework is based on a document and view architecture that resembles Smalltalk's Model/View/Controller framework. In this architecture, the responsibility for a program's data resides with a document object while the responsibility for the user interface is handled by a view. Mfc's framework is quite flexible and can be used to create a wide variety of programs. The chapters in this section develop three applications: one textual, one graphical, and one form-based.

The final part of the text consists of a collection of applications that build on the concepts from the first two parts. Topics include dialog-based applications, dynamic link libraries, and Internet clients.

As you'd expect in a programming text, this book is filled with programs. In creating an example program, there is always a tension between pedagogy and realism. Too many details bury the lesson, but attention to details distinguishes a toy from a tool. I've tried to make every example realistic, although I have skimped on error handling. To keep the text readable, only code excerpts are usually shown. The full program text, as well as the ancillary files needed for building the programs, can be found on the accompanying disk. The Appendix describes the disk.

Thank You

Many people have helped me to make this book what it is. The basis for the text was a course I wrote for the Technology Exchange Company. The material has benefited from the comments of programmers at many companies. Instructors of the course have given me invaluable feedback on the programs and the presentation. Ralph Davis, Joe Newcomer, Bob Oberg, Brent Rector, Ron Reeves, Dick Walter, and Al Williams have all influenced the text. I also appreciate the efforts of those reviewers who read and commented on all or part of the manuscript, including Jack Mathews, Joe Newcomer, Hadar Ziv, Chris Sells, and Sergiu Simmel.

The staff at Addison Wesley Longman has worked diligently to see the book become a reality. My thanks to Ben Ryan, Mike Hendrickson, and John Wait for initiating and guiding the process; Sarah Weaver for riding herd to see the book through production; Arlene Richman for improving the quality of the writing; Jason Jones for assisting with the translation of the text into Adobe FrameMaker; and Carol Nelson for getting the book into bookstores. My thanks also to Bob Russell of Octal Publishing for helping me tame FrameMaker.

Finally and especially, I thank my family--Georgia, Daniel, and Jeannette--for their unbending support during the long march to publication.