CORE Visual C++ 6 - Softcover

Klander, Lars

Softcover

ISBN 10: 0130858595 ISBN 13: 9780130858597

Publisher: Pearson P T R, 1999

Covers all the expert techniques and tools needed to build industrial-strength applications. Provides instruction on how to build sophisticated user interfaces using the Document/View Architecture. Softcover. DLC: C++ (Computer program language).

"synopsis" may belong to another edition of this title.

Review:

Aimed at those with some previous C++ programming knowledge, Lars Klander's CORE Visual C++ 6 covers many necessary features of real-world Windows development with Visual C++ and MFC (Microsoft Foundation Classes). This effective tour of some essential programming techniques can introduce you to Visual C++ successfully for the first time or bring your basic MFC skills up to the next level.

The key feature here is the code needed to solve very real problems any serious developer will likely face on the job. Usually this material is buried in online help, but this text moves it to center stage. For example, the author shows you how use modeless dialog boxes, build property pages and wizards, and work with bitmaps (including device-independent DIBs). There is also excellent coverage of threads and printing techniques and accessing the Windows Registry. Short code samples are the rule here, and the author provides both the strategy and the MFC APIs required to do real work. Later sections look at COM-centered technologies in MFC like ActiveX controls and the basics of writing OLE DB providers for ADO data sources. A final section demystifies how to build custom AppWizards for the Visual C++ 6 environment, an extremely useful technique to promote code reuse within your software organization.

Of course, there are also numerous MFC tutorials. Core Visual C++ 6 distinguishes itself with a collection of real-world code solutions that will make you more productive. Whether you are approaching MFC for the first time or have some earlier exposure to this library, this title offers plenty of programming gems that no serious Visual C++ developer should go without. --Richard Dragan

Topics covered: Visual C++ 6 new features and environment, overview of debugging features, Windows callback functions and message loops, dialog box programming, dialog data exchange and validation, modeless dialog boxes, property sheets and wizards, MFC graphics tutorial, fonts and bitmaps, device-independent bitmaps (DIBs), document and view basics, single document vs. multiple document interface (MDI), splitters, printing, threads and synchronization objects, memory management techniques, files, serial ports, console applications, anonymous and named pipes, mailslots, Registry overview and APIs, exception handling in MFC and Win32, DCOM basics, ActiveX servers, OLE drag and drop, OLE DB, ADO and databases, scripting the Visual C++ environment, and custom AppWizards.

From the Inside Flap:

To the Reader

When Prentice Hall first approached me about writing a Core Visual C++ title, I must admit that I was a bit apprehensive - the language is so broad, and the amount of information necessary to do it justice so extensive, that I was concerned about my ability to put together an effective title that would yield real value to the reader. Add to that, Gary Cornell's programming works on writing with C++, and I wasn't quite sure where such a book would fit in. Obviously, they convinced me that it would.

But, in writing a book to meet their needs, it quickly became self-evident that we couldn't cover all of the topics important to Visual C++ programming. In fact, many peripheral topics about the compiler and programming over Windows, including the use of the Microsoft Foundation Classes (MFC) library, are substantial enough to demand their own books. Instead, it was necessary to tighten the scope of the book a bit. And so, I focused on a more low- to mid-level introduction to the language and the compiler, and on the issues virtually guaranteed to confront any developer using Visual C++.

To that end, I don't get into using ADO with databases, or using the DirectX family of COM objects for real-time graphical-interface design. Instead, I spent the time talking about crucial, real-world topics, such as memory management, thread management, and exception handling.

As a side note, when any book is being written, errors and inaccuracies are inevitable. I would very much like you, the readers, to tell me about any such problems you encounter with the code in this book. However, while I am happy for you to send me e-mail at lklander@lvcm. To make your life easier, and mine, I will also place such information, after I have the chance to review it for accuracy, onto the same site, so you can review other people's thoughts. Finally, there are probably applications that tie closely in with the topics in these chapters which are not included herein. As such programs occur to me, or as I implement them in other areas of my business, I will happily place such code, as I am able, onto this site. I urge you to provide me with code you think will be helpful, as well.About this Book

For starters, even though this book is written in an educational style, chapters in this book can almost certainly be read in any order you choose. The only exceptions that I would suggest are Chapter 1, which highlights some of the important technologies that we will be looking at over the course of the book's pages, and Chapter 2, which explains in-depth how to work with the Visual C++ Interactive Development Environment (IDE) and how to use the provided debugger to its best effect when designing your applications. Therefore, to help you navigate your way through the book, the following paragraphs provide short descriptions of each of the chapters.

I have started out the book with a brief introduction to Visual C++ 6.0 and Visual Studio, with an eye towards letting the reader know what's new in the product. Some of these new features are important because they will help the reader use the product more efficiently, others are important simply because of new functionality they expose. In Chapter 2, I move on to a discussion of debugging and the integrated debugger, because it is inevitable that the reader will have to use the debugger when writing programs in Visual C++.

After introducing the Interactive Development Environment and some of the tools that work with it, the book moves on to a discussion of the basic Windows programming environment in Chapter 3, with a focus on the nature of callback functions and the Windows message loop. Then the book discusses dialog boxes, common dialogs, and controls as the most fundamental interface design tools, in Chapter 4. In Chapter 5, I move on to a discussion of property sheets, how to build and use them, and focus on them primarily from the perspective of how you might use them in your applications to provide the user with choices, and how even the most complex property sheets are nothing more than a series of dialog boxes. In Chapter 6, I introduce you to graphic device interface (GDI) objects and discuss how you work with them, both from a Windows-native level and from the perspective of MFC classes and objects.

Once the fundamental interface tools are described - dialog boxes and controls - the book moves on, in Chapter 7, to the Windows document/view architecture, and how applications can use this architecture to more efficiently manage both the interface and the storage of data. Chapter 8 diverges briefly into a discussion of printing from the architecture, since output is an important and often neglected topic.

In Chapter 9, the book moves on to a more advanced topic, introducing you to the specifics of working with threads and thread management objects. The chapter includes discussions on multithreading, when and why to use it (or not use it), and the various constructs, such as mutexes and semaphores, necessary to implement and make effective use of multithreading support. Chapter 10 moves on to the consideration of a related topic, looking at the complexities of memory management in the Win32 model and how to make the most effective use of some of the constructs that Win32 provides for managing memory.

The file system, how to interact with it, and the classes and methods at the programmer's disposal for file work are discussed in Chapter 11. We take a look at the many different techniques available to you for file-system access, focusing on the implementations provided by MFC and the Windows API for simplifying file management, creation, and so on. In Chapter 12, a brief introduction to network issues, in the form of file-system derivative objects such as pipes and mailslots, begins to open up your programming universe to some of the innate complexity and power of the Win32 networking environment.

Chapter 13 explores one of the most important programming issues when designing over any of the variants of the Win32 platform - working with the Windows registry. How to manage the registry is a very important consideration for applications that maintain any ongoing data about their activities. Chapter 14 steps back a little from all the operating-system and network operating-system discussions in the previous chapters, instead detailing specifics about exception-handling issues with Visual C++, including the MFC exception classes and their uses.

In Chapter 15, the tone changes a little, letting you move into working with slightly more advanced implementations of Visual C++ and address more complex programming topics. Chapter 15 discusses the nature of Component Object Model (COM) and Distributed Component Object Model (DCOM) programming, and introduces you to some of the issues that you will need to consider when using either from Visual C++.

In Chapter 16, I take the general knowledge discussed in Chapter 15 and apply it to the specifics of the design on dynamic link libraries (DLLs) - in-process servers. The design of in-process servers is one of the most common activities that component-based development entails. In Chapter 17, I move away from the COM focus of the previous two chapters and discuss how to implement OLE drag-and-drop support. Such support has been commonplace enough to be an expected feature, not a "bell or whistle." So making sure you know how to implement such support is important.

Finally, the last two chapters wrap it all up by taking a brief look at some of the finishing techniques at the reader's disposal when programming with Visual C++ - creating an installation tool and performing scripting within the IDE to automate repetitive processes.

All in all, the book is designed in a manner that tries to manage a logical progression through Windows programming topics - from the most fundamental to some of the more advanced and powerful actions. Unlike many books, it is directed at the programmer who is somewhat knowledgeable in other programming languages (or even C/C++), but without significant experience in Visual C++. ConventionsAs is common throughout the Core series, I use courier type to represent computer code.There are Core Notes in this book that examine some of the differences between Visual C++ and other language implementations, including Visual Basic and Java. You can skip over these if you have no experience or interest in either of these languages. Notes are tagged with this icon:

"About this title" may belong to another edition of this title.