Kate Gregory is a founding partner of Gregory Consulting Limited (www.gregcons.com), which has been providing consulting and development services throughout North America since 1986. Her experience with C++ stretches back to before Visual C++ existed--she enthusiastically converted upon seeing the first release. Gregory Consulting develops software and Web sites and specializes in combining software development with Web site development to create active sites. They build quality custom and off-the-shelf software components for Web pages and other applications.
To my children, Beth and Kevin, who keep me connected to the world away from the keyboard, and remind me every day how good it feels to learn new things.
Writng a book is hard, hard work. What makes it possible is the support I get from those around me. First, as always, my family, Brian, Beth, and Kevin, who know it's only temporary. Brian does double duty as both supportive husband and world's best technical editor. This time around I was lucky enough to have Bryan Oliver helping, shooting figures, testing code, finding bugs, and generally pitching in. Thanks, Bryan.
There's an army of editors, proofers, indexers, illustrators, and general saints who turn my Word documents into the book you hold in your hand. Many of the team members this time have been involved in other Que projects with me, and I know that I landed the "good ones" for this book. Special mention has to go to Olaf Meding, who provided a terrific tech edit based on a fast-changing product. Joe Massoni and Mike Blaszczak at Microsoft have also earned my gratitude during this release cycle.
While I cheerfully share the credit for the accurate and educational aspects of this book, the mistakes and omissions I have to claim as mine alone. Please bring them to my attention so that they can be corrected in subsequent printings and editions. I am as grateful as ever to readers who have done so in the past, and improved this book in the process.
Introduction
Visual C++ is a powerful and complex tool for building 32-bit applications for Window 95 and Windows NT. These applications are much larger and more complex than their predecessors for 16-bit Windows or older programs that didn't use a graphical user interface. Yet, as program size and complexity has increased, programmer effort has decreased, at least for programmers who are using the right tools.
Visual C++ is one of the right tools. With its code-generating wizards, it can produce the shell of a working Windows application in seconds. The class library included with Visual C++, the Microsoft Foundation Classes (MFC), has become the industry standard for Windows software development in a variety of C++ compilers. The visual editing tools make layout of menus and dialogs a snap. The time you invest in learning to use this product will pay for itself on your first Windows programming project.
This book teaches you how to use Visual C++ to build 32-bit Windows applications, including database applications, Internet applications, and applications that tap the power of the ActiveX technology. That's a tall order, and to fit all that in less than a thousand pages, some things have to go. This book does not teach you the following:
You should read this book if you fit one of these categories:
You need a copy of Visual C++ 6 and must have it installed. The installation process is simple and easy to follow, so it's not covered in this book.
Before you buy Visual C++ 6, you need a 32-bit Windows operating system: Windows 95, Windows 98, or Windows NT Server or Workstation. That means your machine must be reasonably powerful and modern--say, a 486 or better for your processor, at least 16MB of RAM and 500MB of disk space, and a screen that can do 800 * 600 pixel displays or even finer resolutions. The illustrations in this book were all prepared at a resolution of 800 * 600 and, as you will see, at times things become a little crowded. The sample code is all available on the Web, so following along will be simpler if you also have a modem and access to the Web.
Finally, you need to make a promise to yourself--that you will follow along in Visual C++ as you read this book, clicking and typing and trying things out. You don't need to type all the code if you don't want to: It's all on the Web site for you to look at. However, you should be ready to open the files and look at the code as you go.
A topic such as Windows programming in Visual C++ covers a lot of ground. This book contains 28 chapters and 6 reference appendixes (A to F). Be sure to look over the titles of the appendixes now and turn to them whenever you are unsure how to do something. They provide valuable references for the following:
Depending on your background and willingness to poke around in menus and the online help, you might just skim these appendixes once and never return, or you might fill them full of bookmarks and yellow stickies. Although they don't lead you through the sample applications, they will teach you a lot.
The mainstream of the book is in Chapters 1 through 28. Each chapter teaches you an important programming task or sometimes two closely related tasks, such as building a taskbar or adding Help to an application. Detailed instructions show you how to build a working application, or several working applications, in each chapter.
The first nine chapters cover concepts found in almost every Windows application; after that, the tasks become less general. Here's a brief overview of some of the work that is covered.
What Windows program doesn't have a dialog box? an edit box? a button? Dialog boxes and controls are vital to Windows user interfaces, and all of them, even the simple button or piece of static text, are windows. The common controls enable you to take advantage of the learning time users have devoted to other programs and the programming time developers have put in on the operating system in order to use the same File Open dialog box as everybody else, the same hierarchical tree control, and so on. Learn more about all these controls in Chapters 2, "Dialogs and Controls," and 10, "Windows 95 Common Controls."
Messages form the heart of Windows programming. Whenever anything happens on a Windows machine, such as a user clicking the mouse or pressing a key, a message is triggered and sent to one or more windows, which do something about it. Visual C++ makes it easy for you to write code that catches these messages and acts on them. Chapter 3, "Messages and Commands," explains the concept of messages and how MFC and other aspects of Visual C++ enable you to deal with them.
A paradigm is a model, a way of looking at things. The designers of MFC chose to design the framework based on the assumption that every program has something it wants to save in a file. That collection of information is referred to as the document. A view is one way of looking at a document. There are many advantages to separating the view and the document, explained further in Chapter 4, "Documents and Views." MFC provides classes from which to inherit your document class and your view class, so that common programming tasks such as implementing scrollbars are no longer your problem.
No matter how smart your Windows program is, if you can't tell the user what's going on by putting some words or pictures onscreen, no one will know what the program has done. A remarkable amount of the work is automatically done by your view classes (one of the advantages of adopting the document/view paradigm), but at times you have to do the drawing yourself. You learn about device contexts, scrolling, and more in Chapter 5, "Drawing on the Screen."
Adding printing capabilities to your program is sometimes the simplest thing in the world because the code you use to draw onscreen can be reused to draw on paper. If more than one page of information is involved, though, things become tricky. Chapter 6, "Printing and Print Preview," explains all this, as well as mapping modes, headers and footers, and more.
Some good things are meant to be only temporary, such as the display of a calculator or an online chat window. However, most programs can save their documents to a file and open and load that file to re-create a document that has been stored. MFC simplifies this by using archives and extending the use of the stream I/O operators >> and <<. You learn all about reading and writing to files in Chapter 7, "Persistence and File I/O."
ActiveX is the successor to OLE, and it's the technology that facilitates communication between applications at the object level, enabling you to embed a Word document in an Excel spreadsheet or to embed any of hundreds of kinds of objects in any ActiveX application. ActiveX chapters include Chapters 13, "ActiveX Concepts," 14, "Building an ActiveX Container Application," 15, "Building an ActiveX Server Application," 16, "Building an Automation Server," and 17, "Building an ActiveX Control."
Microsoft recognizes that distributed computing, in which work is shared between two or more computers, is becoming more and more common. Programs need to talk to each other, people need to send messages across a LAN or around the world, and MFC has classes that support these kinds of communication. The four Internet chapters in this book are Chapter 18, "Sockets, MAPI, and the Internet," Chapter 19, "Internet Programming with the WinInet Classes," Chapter 20, "Building an Internet ActiveX Control," and Chapter 21, "The Active Template Library."
Database programming keeps getting easier. ODBC, Microsoft's Open DataBase Connectivity package, enables your code to call API functions that access a huge variety of database files--Oracle, DBase, an Excel spreadsheet, a plain text file, old legacy mainframe systems using SQL, whatever! You call a standard name function, and the API provided by the database vendor or a third party handles the translation. The details are in Chapters 22, "Database Access," and 23, "SQL and the Enterprise Edition."
For developers who have mastered the basics, this book features some advanced chapters to move your programming skills forward. You will learn how to prevent memory leaks, find bottlenecks, and locate bugs in your code with the techniques discussed in Chapter 24, "Improving Your Application's Performance."
Reuse is a hugely popular concept in software development at the moment, especially with managers who see a chance to lower their development budget. If you'd like to write reusable code and components, Chapter 25, "Achieving Reuse with the Gallery and Your Own AppWizards," will take you there.
Often C++ programmers are so busy learning the basics of how to make programs work that they miss the features that make C++ truly powerful. You will learn in Chapter 26, "Exceptions and Templates," how to catch errors efficiently and how to use one set of code in many different situations.
As user demands for high-performance software continue to multiply, developers must learn entirely new techniques to produce powerful applications that provide fast response times. For many developers, writing multithreaded applications is a vital technique. Learn about threading in Chapter 27, "Multitasking with Windows Threads."
Chapter 28, "Future Explorations," introduces you to topics that are definitely not for beginners. Learn how to create console applications, use and build your own DLLs, and work with Unicode.
One thing this book has plenty of is code. Sometimes you need to see only a line or two, so the code is mixed in with the text, like this:
int SomeFunction( int x, int y);
{
return x+y;
}
You can tell the difference between code and regular text by the fonts used for each. Sometimes, you'll see a piece of code that's too large to mix in with the text: You will find an example in Listing 0.1.
CHostDialog dialog(m_pMainWnd);
if (dialog.DoModal() == IDOK)
{
AppSocket = new CSocket();
if (AppSocket->Connect(dialog.m_hostname,119))
{
while (AppSocket->GetStatus() == CONNECTING)
{
YieldControl();
}
if (AppSocket->GetStatus() == CONNECTED)
{
CString response = AppSocket->GetLine();
SocketAvailable = TRUE;
}
}
}
if (!SocketAvailable)
{
AfxMessageBox("Can't connect to server. Please
¬ quit.",MB_OK|MB_ICONSTOP);
}
The character on the next-to-last line (¬) is called the code continuation character. It indicates a place where a line of code had to be broken to fit it on the page, but in reality the line doesn't break there. If you're typing code from the book, don't break the line there--keep going. If you're reading along in code that was generated for you by Visual C++, don't be confused when the line doesn't break there.
Remember, the code is in the book so that you can understand what's going on, not for you to type it. All the code is on the companion Web site as well. Sometimes you will work your way through the development of an application and see several versions of a block of code as you go--the final version is on the Web site. You'll find the site by going to www.mcp.com/info or www.gregcons.com/uvc6.htm.
TIP: This is a Tip: a shortcut or an interesting feature you might want to know about.
NOTE: This is a Note: It explains a subtle but important point. Don't skip Notes, even if you're the kind who skips Tips. n
CAUTION: This is a Caution, and it's serious. It warns you of the horrible consequences if you make a false step, so be sure to read all of these that you come across.
When a word is being defined or emphasized, it's in italic. The names of variables, functions, and C++ classes are all in monospaced font. Internet URLS and things you should type are in bold. Remember, an URL never ends with punctuation, so ignore any comma or period after the URL.
That about wraps up things for the introduction. You've learned what you need to get started, including some advanced warning about the notations used throughout the book. Jump right in, learn all about writing Windows applications with MFC, and then get started on some development of your own! Good luck and have fun.
© Copyright, Macmillan Computer Publishing. All rights reserved.