book

Ivor Horton's Beginning Visual C++®2008

Name: Ivor Horton's Beginning Visual C++®2008
Author: Ivor Horton
ISBN: 9780470225905

by Ivor Horton

March 2008

Beginner

1390 pages

38h 47m

English

Wrox

Read now

Unlock full access

Copyright
About the Author
Acknowledgments
Credits
Introduction
Whom This Book Is ForWhat This Book CoversHow This Book Is StructuredWhat You Need to Use This BookUsing the Windows Classic ThemeConventionsHow It WorksSource CodeErratap2p.wrox.com
1. Programming with Visual C++ 2008
1.1. The .NET Framework1.2. The Common Language Runtime (CLR)1.3. Writing C++ Applications1.4. Learning Windows Programming1.4.1. Learning C++1.4.2. The C++ Standards1.4.3. Attributes1.4.4. Console Applications1.4.5. Windows Programming Concepts1.5. What Is the Integrated Development Environment?1.5.1. Components of the System1.5.1.1. The Editor1.5.1.2. The Compiler1.5.1.3. The Linker1.5.1.4. The Libraries1.6. Using the IDE1.6.1. Toolbar Options1.6.2. Dockable Toolbars1.6.3. Documentation1.6.4. Projects and Solutions1.6.4.1. Defining a Project1.6.4.1.1. Modifying the Source Code1.6.4.1.2. Building the Solution1.6.4.1.3. Files Created by Building a Console Application1.6.4.2. Debug and Release Versions of Your Program1.6.4.2.1. Executing the Program1.6.4.3. Dealing with Errors1.6.5. Setting Options in Visual C++ 20081.6.6. Creating and Executing Windows Applications1.6.6.1. Creating an MFC Application1.6.6.2. Building and Executing the MFC Application1.6.7. Creating a Windows Forms Application1.7. Summary
2. Data, Variables, and Calculations
2.1. The Structure of a C++ Program2.1.1.2.1.1.1. Program Comments2.1.1.2. The #include Directive—Header Files2.1.1.3. Namespaces and the Using Declaration2.1.2. The main() Function2.1.3. Program Statements2.1.4. Whitespace2.1.5. Statement Blocks2.1.6. Automatically Generated Console Programs2.2. Defining Variables2.2.1. Naming Variables2.2.1.1. Keywords in C++2.2.2. Declaring Variables2.2.3. Initial Values for Variables2.3. Fundamental Data Types2.3.1. Integer Variables2.3.2. Character Data Types2.3.3. Integer Type Modifiers2.3.4. The Boolean Type2.3.5. Floating-Point Types2.3.5.1. Fundamental Types in ISO/ANSI C++2.3.6. Literals2.3.7. Defining Synonyms for Data Types2.3.8. Variables with Specific Sets of Values2.4. Basic Input/Output Operations2.4.1. Input from the Keyboard2.4.2. Output to the Command Line2.4.2.1. How It Works2.4.3. Formatting the Output2.4.3.1. How It Works2.4.4. Escape Sequences2.4.4.1. How It Works2.5. Calculating in C++2.5.1. The Assignment Statement2.5.1.1. Understanding Lvalues and Rvalues2.5.2. Arithmetic Operations2.5.2.1. How It Works2.5.2.2. The const Modifier2.5.2.3. Constant Expressions2.5.2.4. Program Input2.5.2.5. Calculating the Result2.5.2.6. Displaying the Result2.5.3. Calculating a Remainder2.5.4. Modifying a Variable2.5.5. The Increment and Decrement Operators2.5.5.1. How It Works2.5.6. The Sequence of Calculation2.5.6.1. Operator Precedence2.6. Variable Types and Casting2.6.1. Rules for Casting Operands2.6.2. Casts in Assignment Statements2.6.3. Explicit Casts2.6.4. Old-Style Casts2.7. The Bitwise Operators2.7.1. The Bitwise AND2.7.2. The Bitwise OR2.7.3. The Bitwise Exclusive OR2.7.4. The Bitwise NOT2.7.5. The Bitwise Shift Operators2.8. Understanding Storage Duration and Scope2.8.1. Automatic Variables2.8.1.1. How It Works2.8.2. Positioning Variable Declarations2.8.3. Global Variables2.8.3.1. How It Works2.8.4. Static Variables2.9. Namespaces2.9.1. Declaring a Namespace2.9.2. Multiple Namespaces2.10. C++/CLI Programming2.10.1. C++/CLI Specific: Fundamental Data Types2.10.1.1. How It Works2.10.2. C++/CLI Output to the Command Line2.10.3. C++/CLI Specific—Formatting the Output2.10.3.1. How It Works2.10.4. C++/CLI Input from the Keyboard2.10.5. Using safe_cast2.10.6. C++/CLI Enumerations2.10.6.1. How It Works2.10.6.2. Specifying a Type for Enumeration Constants2.10.6.3. Specifying Values for Enumeration Constants2.10.6.4. Operations on Enumeration Constants2.10.6.5. Using Enumerators as Flags2.10.6.6. Native Enumerations in a C++/CLI Program2.11. Summary2.12. Exercises
3. Decisions and Loops
3.1. Comparing Values3.1.1. The if Statement3.1.2. Nested if Statements3.1.2.1. How It Works3.1.2.2. The Extended if Statement3.1.2.3. How It Works3.1.3. Nested if-else Statements3.1.4. Logical Operators and Expressions3.1.4.1. Logical AND3.1.4.2. Logical OR3.1.4.3. Logical NOT3.1.4.4. How It Works3.1.5. The Conditional Operator3.1.5.1. How It Works3.1.6. The switch Statement3.1.6.1. How It Works3.1.6.2. How It Works3.1.7. Unconditional Branching3.2. Repeating a Block of Statements3.2.1. What Is a Loop?3.2.1.1. How It Works3.2.2. Variations on the for Loop3.2.2.1. How It Works3.2.2.2. How It Works3.2.2.3. Using the continue Statement3.2.2.4. How It Works3.2.2.5. Floating-Point Loop Counters3.2.3. The while Loop3.2.3.1. How It Works3.2.4. The do-while Loop3.2.5. Nested Loops3.2.5.1. How It Works3.2.5.2. How It Works3.3. C++/CLI Programming3.3.1.3.3.1.1. How It Works3.3.1.2. How It Works3.3.2. The for each Loop3.3.2.1. How It Works3.4. Summary3.5. Exercises
4. Arrays, Strings, and Pointers
4.1. Handling Multiple Data Values of the Same Type4.1.1. Arrays4.1.2. Declaring Arrays4.1.2.1. How It Works4.1.2.2. Entering the Data4.1.2.3. Producing the Results4.1.3. Initializing Arrays4.1.3.1. How It Works4.1.4. Character Arrays and String Handling4.1.4.1. String Input4.1.4.2. How It Works4.1.5. Multidimensional Arrays4.1.5.1. Initializing Multidimensional Arrays4.1.5.2. How It Works4.2. Indirect Data Access4.2.1. What Is a Pointer?4.2.2. Declaring Pointers4.2.2.1. The Address-Of Operator4.2.3. Using Pointers4.2.3.1. The Indirection Operator4.2.3.2. Why Use Pointers?4.2.3.3. How It Works4.2.4. Initializing Pointers4.2.4.1. Pointers to char4.2.4.2. How It Works4.2.4.3. How It Works4.2.5. The sizeof Operator4.2.5.1. How It Works4.2.6. Constant Pointers and Pointers to Constants4.2.7. Pointers and Arrays4.2.7.1. Pointer Arithmetic4.2.7.2. How It Works4.2.7.3. How It Works4.2.7.4. Using Pointers with Multidimensional Arrays4.2.7.5. Pointer Notation with Multidimensional Arrays4.3. Dynamic Memory Allocation4.3.1. The Free Store, Alias the Heap4.3.2. The new and delete Operators4.3.3. Allocating Memory Dynamically for Arrays4.3.3.1. How It Works4.3.4. Dynamic Allocation of Multidimensional Arrays4.4. Using References4.4.1. What Is a Reference?4.4.2. Declaring and Initializing References4.5. Native C++ Library Functions for Strings4.5.1. Finding the Length of a Null-Terminated String4.5.2. Joining Null-Terminated Strings4.5.3. Copying Null-Terminated Strings4.5.4. Comparing Null-Terminated Strings4.5.5. Searching Null-Terminated Strings4.5.5.1. How It Works4.6. C++/CLI Programming4.6.1. Tracking Handles4.6.1.1. Declaring Tracking Handles4.6.2. CLR Arrays4.6.2.1. How It Works4.6.2.2. Sorting One-Dimensional Arrays4.6.2.3. How It Works4.6.2.4. Searching One-Dimensional Arrays4.6.2.5. How It Works4.6.2.6. Multidimensional Arrays4.6.2.7. How It Works4.6.2.8. Arrays of Arrays4.6.2.9. How It Works4.6.3. Strings4.6.3.1. Joining Strings4.6.3.2. How It Works4.6.3.3. Modifying Strings4.6.3.4. Comparing Strings4.6.3.5. Searching Strings4.6.3.6. How It Works4.6.4. Tracking References4.6.5. Interior Pointers4.6.5.1. How It Works4.7. Summary4.8. Exercises
5. Introducing Structure into Your Programs
5.1. Understanding Functions5.1.1. Why Do You Need Functions?5.1.2. Structure of a Function5.1.2.1. The Function Header5.1.2.1.1. The General Form of a Function Header5.1.2.2. The Function Body5.1.2.3. The return Statement5.1.3. Using a Function5.1.3.1. Function Prototypes5.1.3.2. How It Works5.2. Passing Arguments to a Function5.2.1. The Pass-by-value Mechanism5.2.1.1. How It Works5.2.2. Pointers as Arguments to a Function5.2.2.1. How It Works5.2.3. Passing Arrays to a Function5.2.3.1. How It Works5.2.3.2. How It Works5.2.3.3. Passing Multidimensional Arrays to a Function5.2.3.4. How It Works5.2.4. References as Arguments to a Function5.2.4.1. How It Works5.2.5. Use of the const Modifier5.2.5.1. How It Works5.2.6. Arguments to main()5.2.6.1. How It Works5.2.7. Accepting a Variable Number of Function Arguments5.2.7.1. How It Works5.3. Returning Values from a Function5.3.1. Returning a Pointer5.3.1.1. How It Works (or Why It Doesn't)5.3.1.2. A Cast Iron Rule for Returning Addresses5.3.2. Returning a Reference5.3.2.1. How It Works5.3.2.2. A Teflon-Coated Rule: Returning References5.3.3. Static Variables in a Function5.3.3.1. How It Works5.4. Recursive Function Calls5.4.1.5.4.1.1. How It Works5.4.2. Using Recursion5.5. C++/CLI Programming5.5.1. Functions Accepting a Variable Number of Arguments5.5.1.1. How It Works5.5.2. Arguments to main()5.5.2.1. How It Works5.6. Summary5.7. Exercises

6. More about Program Structure
6.1. Pointers to Functions6.1.1. Declaring Pointers to Functions6.1.1.1. How It Works6.1.2. A Pointer to a Function as an Argument6.1.2.1. How It Works6.1.3. Arrays of Pointers to Functions6.2. Initializing Function Parameters6.2.1.6.2.1.1. How It Works6.3. Exceptions6.3.1.6.3.1.1. How It Works6.3.2. Throwing Exceptions6.3.3. Catching Exceptions6.3.3.1. How It Works6.3.4. Exception Handling in the MFC6.4. Handling Memory Allocation Errors6.4.1.6.4.1.1. How It Works6.5. Function Overloading6.5.1. What Is Function Overloading?6.5.1.1. How It Works6.5.2. When to Overload Functions6.6. Function Templates6.6.1. Using a Function Template6.6.1.1. How It Works6.7. An Example Using Functions6.7.1. Implementing a Calculator6.7.1.1. Analyzing the Problem6.7.2. Eliminating Blanks from a String6.7.2.1. How the Function Functions6.7.3. Evaluating an Expression6.7.3.1. How the Function Functions6.7.4. Getting the Value of a Term6.7.4.1. How the Function Functions6.7.5. Analyzing a Number6.7.5.1. How the Function Functions6.7.6. Putting the Program Together6.7.6.1. How the Function Functions6.7.7. Extending the Program6.7.7.1. How the Function Functions6.7.8. Extracting a Substring6.7.8.1. How the Function Functions6.7.9. Running the Modified Program6.8. C++/CLI Programming6.8.1. Understanding Generic Functions6.8.1.1. Defining Generic Functions6.8.1.2. Using Generic Functions6.8.1.3. How It Works6.8.2. A Calculator Program for the CLR6.8.2.1. Removing Spaces from the Input String6.8.2.2. Evaluating an Arithmetic Expression6.8.2.3. Obtaining the Value of a Term6.8.2.4. Evaluating a Number6.8.2.5. Extracting a Parenthesized Substring6.9. Summary6.10. Exercises
7. Defining Your Own Data Types
7.1. The struct in C++7.1.1. What Is a struct?7.1.2. Defining a struct7.1.3. Initializing a struct7.1.4. Accessing the Members of a struct7.1.4.1. How It Works7.1.5. IntelliSense Assistance with Structures7.1.6. The struct RECT7.1.7. Using Pointers with a struct7.1.7.1. Accessing Structure Members through a Pointer7.1.7.2. The Indirect Member Selection Operator7.2. Data Types, Objects, Classes, and Instances7.2.1. First Class7.2.2. Operations on Classes7.2.3. Terminology7.3. Understanding Classes7.3.1. Defining a Class7.3.1.1. Access Control in a Class7.3.2. Declaring Objects of a Class7.3.3. Accessing the Data Members of a Class7.3.3.1. How It Works7.3.4. Member Functions of a Class7.3.4.1. How It Works7.3.5. Positioning a Member Function Definition7.3.6. Inline Functions7.4. Class Constructors7.4.1. What Is a Constructor?7.4.1.1. How It Works7.4.2. The Default Constructor7.4.2.1. How It Works7.4.3. Assigning Default Parameter Values in a Class7.4.3.1. How It Works7.4.4. Using an Initialization List in a Constructor7.5. Private Members of a Class7.5.1.7.5.1.1. How It Works7.5.2. Accessing private Class Members7.5.3. The friend Functions of a Class7.5.3.1. How It Works7.5.3.2. Placing friend Function Definitions Inside the Class7.5.4. The Default Copy Constructor7.5.4.1. How It Works7.6. The Pointer this7.6.1.7.6.1.1. How It Works7.7. const Objects of a Class7.7.1. const Member Functions of a Class7.7.2. Member Function Definitions Outside the Class7.8. Arrays of Objects of a Class7.8.1.7.8.1.1. How It Works7.9. Static Members of a Class7.9.1. Static Data Members of a Class7.9.1.1. How It Works7.9.2. Static Function Members of a Class7.10. Pointers and References to Class Objects7.10.1. Pointers to Class Objects7.10.1.1. How It Works7.10.2. References to Class Objects7.10.2.1. Implementing a Copy Constructor7.11. C++/CLI Programming7.11.1. Defining Value Class Types7.11.1.1. How It Works7.11.1.2. The ToString() Function in a Class7.11.1.3. Literal Fields7.11.2. Defining Reference Class Types7.11.2.1. How It Works7.11.3. Defining a Copy Constructor for a Reference Class Type7.11.4. Class Properties7.11.4.1. Defining Scalar Properties7.11.4.2. Trivial Scalar Properties7.11.4.3. How It Works7.11.4.4. Defining Indexed Properties7.11.4.5. How It Works7.11.4.6. More Complex Indexed Properties7.11.4.7. Static Properties7.11.4.8. Reserved Property Names7.11.5. initonly Fields7.11.6. Static Constructors7.12. Summary7.13. Exercises
8. More on Classes
8.1. Class Destructors8.1.1. What Is a Destructor?8.1.2. The Default Destructor8.1.2.1. How It Works8.1.3. Destructors and Dynamic Memory Allocation8.1.3.1. How It Works8.2. Implementing a Copy Constructor8.3. Sharing Memory Between Variables8.3.1. Defining Unions8.3.2. Anonymous Unions8.3.3. Unions in Classes and Structures8.4. Operator Overloading8.4.1. Implementing an Overloaded Operator8.4.1.1. How It Works8.4.2. Implementing Full Support for a Comparison Operator8.4.2.1. How It Works8.4.3. Overloading the Assignment Operator8.4.3.1. Fixing the Problem8.4.4. Overloading the Addition Operator8.4.4.1. How It Works8.4.5. Overloading the Increment and Decrement Operators8.5. Class Templates8.5.1. Defining a Class Template8.5.1.1. Template Member Functions8.5.2. Creating Objects from a Class Template8.5.3. Class Templates with Multiple Parameters8.6. Using Classes8.6.1. The Idea of a Class Interface8.6.2. Defining the Problem8.6.3. Implementing the CBox Class8.6.3.1. Comparing CBox Objects8.6.3.2. Combining CBox Objects8.6.3.3. Analyzing CBox Objects8.6.3.4. Defining the CBox Class8.6.3.5. Adding Data Members8.6.3.6. Defining the Constructor8.6.3.7. Adding Function Members8.6.3.8. Adding Global Functions8.6.3.9. Using Our CBox Class8.6.3.10. How It Works8.7. Organizing Your Program Code8.7.1. Naming Program Files8.8. Native C++ Library Classes for Strings8.8.1. Creating String Objects8.8.2. Concatenating Strings8.8.2.1. How It Works8.8.3. Accessing and Modifying Strings8.8.4. Comparing Strings8.8.4.1. How It Works8.8.5. Searching Strings8.8.5.1. How It Works8.9. C++/CLI Programming8.9.1. Overloading Operators in Value Classes8.9.1.1. How It Works8.9.2. Overloading the Increment and Decrement Operators8.9.3. Overloading Operators in Reference Classes8.9.3.1. How It Works8.9.4. Implementing the Assignment Operator for Reference Types8.10. Summary8.11. Exercises
9. Class Inheritance and Virtual Functions
9.1. Basic Ideas of OOP9.2. Inheritance in Classes9.2.1. What Is a Base Class?9.2.2. Deriving Classes from a Base Class9.2.2.1. How It Works9.3. Access Control Under Inheritance9.3.1.9.3.1.1. How It Works9.3.2. Constructor Operation in a Derived Class9.3.2.1. How It Works9.3.3. Declaring Class Members to Be Protected9.3.3.1. How It Works9.3.4. The Access Level of Inherited Class Members9.4. The Copy Constructor in a Derived Class9.4.1.9.4.1.1. How It Works (or Why It Doesn't)9.4.1.2. How It Works9.5. Class Members as Friends9.5.1. Friend Classes9.5.2. Limitations on Class Friendship9.6. Virtual Functions9.6.1.9.6.1.1. How It Works9.6.2. What Is a Virtual Function?9.6.2.1. How It Works9.6.3. Using Pointers to Class Objects9.6.3.1. How It Works9.6.4. Using References with Virtual Functions9.6.4.1. How It Works9.6.4.2. Incomplete Class Definitions9.6.5. Pure Virtual Functions9.6.6. Abstract Classes9.6.6.1. How It Works9.6.7. Indirect Base Classes9.6.7.1. How It Works9.6.8. Virtual Destructors9.6.8.1. How It Works9.7. Casting Between Class Types9.8. Nested Classes9.8.1.9.8.1.1. How It Works9.9. C++/CLI Programming9.9.1. Boxing and Unboxing9.9.2. Inheritance in C++/CLI Classes9.9.2.1. How It Works9.9.3. Interface Classes9.9.4. Defining Interface Classes9.9.4.1. How It Works9.9.5. Classes and Assemblies9.9.5.1. Visibility Specifiers for Classes and Interfaces9.9.5.2. Access Specifiers for Class and Interface Members9.9.6. Functions Specified as new9.9.7. Delegates and Events9.9.7.1. Declaring Delegates9.9.7.2. Creating Delegates9.9.7.3. How It Works9.9.7.4. Unbound Delegates9.9.7.5. How It Works9.9.7.6. Creating Events9.9.7.7. How It Works9.9.8. Destructors and Finalizers in Reference Classes9.9.8.1. How It Works9.9.9. Generic Classes9.9.9.1. How It Works9.9.9.2. Generic Interface Classes9.9.9.3. Generic Collection Classes9.9.9.3.1. List—A Generic List9.9.9.3.2. LinkedList<T>—A Generic Doubly Linked List9.9.9.3.3. Dictionary<TKey, TValue>—A Generic Dictionary Storing Key/Value Pairs9.9.9.4. How It Works9.10. Summary9.11. Exercises
10. The Standard Template Library
10.1. What Is the Standard Template Library?10.1.1. Containers10.1.2. Container Adapters10.1.3. Iterators10.1.4. Algorithms10.1.5. Function Objects10.1.6. Function Adapters10.2. The Range of STL Containers10.3. Sequence Containers10.3.1. Creating Vector Containers10.3.2. The Capacity and Size of a Vector Container10.3.2.1. How It Works10.3.3. Accessing the Elements in a Vector10.3.4. Inserting and Deleting Elements in a Vector10.3.5. Storing Class Objects in a Vector10.3.5.1. How It Works10.3.6. Sorting Vector Elements10.3.7. Storing Pointers in a Vector10.3.7.1. How It Works10.3.8. Double-Ended Queue Containers10.3.8.1. How It Works10.3.9. Using List Containers10.3.9.1. Adding Elements to a List10.3.9.2. Accessing Elements in a List10.3.9.3. How It Works10.3.9.4. Other Operations on Lists10.3.9.5. How It Works10.3.10. Using Other Sequence Containers10.3.10.1. Queue Containers10.3.10.2. How It Works10.3.10.3. Priority Queue Containers10.3.10.4. How It Works10.3.10.5. Stack Containers10.3.10.6. How It Works10.4. Associative Containers10.4.1. Using Map Containers10.4.1.1. Storing Objects10.4.1.2. Accessing Objects10.4.1.3. Other Map Operations10.4.1.4. How It Works10.4.2. Using a Multimap Container10.5. More on Iterators10.5.1. Using Input Stream Iterators10.5.1.1. How It Works10.5.2. Using Inserter Iterators10.5.3. Using Output Stream Iterators10.5.3.1. How It Works10.6. More on Function Objects10.7. More on Algorithms10.7.1. fill()10.7.2. replace()10.7.3. find()10.7.4. transform()10.8. The STL for C++/CLI Programs10.8.1. STL/CLR Containers10.8.2. Using Sequence Containers10.8.2.1. How It Works10.8.2.2. How It Works10.8.2.3. How It Works10.8.3. Using Associative Containers10.8.3.1. How It Works10.9. Summary10.10. Exercises
11. Debugging Techniques
11.1. Understanding Debugging11.1.1. Program Bugs11.1.2. Common Bugs11.2. Basic Debugging Operations11.2.1. Setting Breakpoints11.2.1.1. Advanced Breakpoints11.2.2. Setting Tracepoints11.2.3. Starting Debugging11.2.3.1. Inspecting Variable Values11.2.3.2. Viewing Variables in the Edit Window11.2.4. Changing the Value of a Variable11.3. Adding Debugging Code11.3.1. Using Assertions11.3.2. Adding Your Own Debugging Code11.3.2.1. How It Works11.4. Debugging a Program11.4.1. The Call Stack11.4.2. Step Over to the Error11.5. Testing the Extended Class11.5.1. Finding the Next Bug11.6. Debugging Dynamic Memory11.6.1. Functions Checking the Free Store11.6.2. Controlling Free Store Debug Operations11.6.3. Free Store Debugging Output11.6.3.1. How It Works11.7. Debugging C++/CLI Programs11.7.1. Using the Debug and Trace Classes11.7.1.1. Generating Output11.7.1.2. Setting the Output Destination11.7.1.3. Indenting the Output11.7.1.4. Controlling Output11.7.1.5. Assertions11.7.1.6. How It Works11.7.2. Getting Trace Output in Windows Forms Applications11.8. Summary
12. Windows Programming Concepts
12.1. Windows Programming Basics12.1.1. Elements of a Window12.1.2. Windows Programs and the Operating System12.1.3. Event-Driven Programs12.1.4. Windows Messages12.1.5. The Windows API12.1.6. Windows Data Types12.1.7. Notation in Windows Programs12.2. The Structure of a Windows Program12.2.1. The WinMain() Function12.2.1.1. Specifying a Program Window12.2.1.2. Creating a Program Window12.2.1.3. Initializing the Program Window12.2.1.4. Dealing with Windows Messages12.2.1.4.1. Queued and Non-Queued Messages12.2.1.4.2. The Message Loop12.2.1.4.3. Multitasking12.2.1.5. A Complete WinMain() Function12.2.1.6. How It Works12.2.2. Message Processing Functions12.2.2.1. The WindowProc() Function12.2.2.2. Decoding a Windows Message12.2.2.2.1. Drawing the Window Client Area12.2.2.3. Ending the Program12.2.2.4. A Complete WindowProc() Function12.2.2.5. How It Works12.2.3. A Simple Windows Program12.3. Windows Program Organization12.4. The Microsoft Foundation Classes12.4.1. MFC Notation12.4.2. How an MFC Program Is Structured12.4.2.1. The Application Class12.4.2.2. The Window Class12.4.2.3. Completing the Program12.4.2.4. The Finished Product12.4.2.5. How It Works12.5. Using Windows Forms12.5.1.12.5.1.1. How It Works12.6. Summary
13. Windows Programming with the Microsoft Foundation Classes
13.1. The Document/View Concept in MFC13.1.1. What Is a Document?13.1.2. Document Interfaces13.1.3. What Is a View?13.1.4. Linking a Document and Its Views13.1.4.1. Document Templates13.1.4.2. Document Template Classes13.1.5. Your Application and MFC13.2. Creating MFC Applications13.2.1. Creating an SDI Application13.2.2. The Output from the MFC Application Wizard13.2.2.1. Viewing Project Files13.2.2.2. Viewing Classes13.2.2.3. The Class Definitions13.2.2.4. Creating an Executable Module13.2.2.4.1. Precompiled Header Files13.2.2.5. Running the Program13.2.2.6. How the Program Works13.2.2.6.1. The InitInstance() Function13.2.2.6.2. The Run() Function13.2.3. Creating an MDI Application13.2.3.1. Running the Program13.3. Summary13.4. Exercises
14. Working with Menus and Toolbars
14.1. Communicating with Windows14.1.1. Understanding Message Maps14.1.1.1. Message Handler Definitions14.1.2. Message Categories14.1.3. Handling Messages in Your Program14.1.3.1. How Command Messages Are Processed14.2. Extending the Sketcher Program14.3. Elements of a Menu14.3.1. Creating and Editing Menu Resources14.3.1.1. Adding a Menu Item to the Menu Bar14.3.1.2. Adding Items to the Element Menu14.3.1.3. Modifying Existing Menu Items14.3.1.4. Completing the Menu14.4. Adding Handlers for Menu Messages14.4.1. Choosing a Class to Handle Menu Messages14.4.2. Creating Menu Message Functions14.4.3. Coding Menu Message Functions14.4.3.1. Adding Members to Store Color and Element Mode14.4.3.2. Initializing the New Class Data Members14.4.3.2.1. Modifying the Class Constructor14.4.3.3. Running the Extended Example14.4.4. Adding Message Handlers to Update the User Interface14.4.4.1. Coding a Command Update Handler14.4.4.2. Exercising the Update Handlers14.5. Adding Toolbar Buttons14.5.1. Editing Toolbar Button Properties14.5.2. Exercising the Toolbar Buttons14.5.3. Adding Tooltips14.6. Menu and Toolbars in a C++/CLI Program14.6.1. Understanding Windows Forms14.6.2. Understanding Windows Forms Applications14.6.2.1. Modifying the Properties of a Form14.6.2.2. How the Application Starts14.6.3. Adding a Menu to CLR Sketcher14.6.4. Adding Event Handlers for Menu Items14.6.5. Implementing Event Handlers14.6.6. Setting Menu Item Checks14.6.7. Adding a Toolbar14.7. Summary14.8. Exercises
15. Drawing in a Window
15.1. Basics of Drawing in a Window15.1.1. The Window Client Area15.1.2. The Windows Graphical Device Interface15.1.2.1. What Is a Device Context?15.1.2.2. Mapping Modes15.2. The Drawing Mechanism in Visual C++15.2.1. The View Class in Your Application15.2.1.1. The OnDraw() Member Function15.2.2. The CDC Class15.2.2.1. Displaying Graphics15.2.2.1.1. Drawing Lines15.2.2.1.2. Drawing Circles15.2.2.2. Drawing in Color15.2.2.2.1. Creating a Pen15.2.2.2.2. Using a Pen15.2.2.2.3. Creating a Brush15.2.2.2.4. Using a Brush15.3. Drawing Graphics in Practice15.4. Programming the Mouse15.4.1. Messages from the Mouse15.4.1.1. WM_LBUTTONDOWN15.4.1.2. WM_MOUSEMOVE15.4.1.3. WM_LBUTTONUP15.4.2. Mouse Message Handlers15.4.3. Drawing Using the Mouse15.4.3.1. Getting the Client Area Redrawn15.4.3.2. Defining Classes for Elements15.4.3.2.1. Storing a Temporary Element in the View15.4.3.3. The CElement Class15.4.3.4. The CLine Class15.4.3.4.1. Implementing the CLine Class15.4.3.4.2. The CLine Class Constructor15.4.3.4.3. Drawing a Line15.4.3.4.4. Creating Bounding Rectangles15.4.3.4.5. Normalized Rectangles15.4.3.5. Calculating the Enclosing Rectangle for a Line15.4.3.6. The CRectangle Class15.4.3.6.1. The CRectangle Class Constructor15.4.3.6.2. Drawing a Rectangle15.4.3.7. The CCircle Class15.4.3.7.1. Implementing the CCircle Class15.4.3.7.2. The CCircle Class Constructor15.4.3.7.3. Drawing a Circle15.4.3.8. The CCurve Class15.4.3.9. Completing the Mouse Message Handlers15.4.3.9.1. Setting the Drawing Mode15.4.3.9.2. Coding the OnMouseMove() Handler15.4.3.9.3. Creating an Element15.4.3.9.4. Dealing with WM_LBUTTONUP Messages15.5. Exercising Sketcher15.5.1. Running the Example15.5.2. Capturing Mouse Messages15.6. Drawing with the CLR15.6.1. Drawing on a Form15.6.2. Adding Mouse Event Handlers15.6.3. Defining C++/CLI Element Classes15.6.3.1. Defining a Line15.6.3.1.1. Defining a Color15.6.3.1.2. Drawing Lines15.6.3.1.3. Defining a Pen for Drawing15.6.3.1.4. Standard Pens15.6.3.2. Defining a Rectangle15.6.3.3. Defining a Circle15.6.4. Implementing the MouseMove Event Handler15.6.5. Implementing the MouseUp Event Handler15.6.6. Implementing the Paint Event Handler for the Form15.7. Summary15.8. Exercises
16. Creating the Document and Improving the View
16.1. The MFC Collection Classes16.1.1. Types of Collection16.1.2. The Type-Safe Collection Classes16.1.3. Collections of Objects16.1.3.1. The CArray Template Class16.1.3.2. Helper Functions16.1.3.3. The CList Template Class16.1.3.3.1. Adding Elements to a List16.1.3.3.2. Iterating through a List16.1.3.3.3. Searching a List16.1.3.3.4. Deleting Objects from a List16.1.3.3.5. Helper Functions for a List16.1.3.4. The CMap Template Class16.1.3.4.1. Helper Functions Used by CMap16.1.4. The Typed Pointer Collections16.1.4.1. The CTypedPtrList Template Class16.1.4.2. CTypePtrList Operations16.2. Using the CList Template Class16.2.1. Drawing a Curve16.2.2. Defining the CCurve Class16.2.3. Implementing the CCurve Class16.2.4. Exercising the CCurve Class16.3. Creating the Sketch Document16.3.1. Using a CTypedPtrList Template16.3.1.1. Implementing the Document Destructor16.3.1.2. Drawing the Document16.3.1.3. Adding an Element to the Document16.3.1.4. Exercising the Document16.4. Improving the View16.4.1. Updating Multiple Views16.4.2. Scrolling Views16.4.2.1. Logical Coordinates and Client Coordinates16.4.2.2. Dealing with Client Coordinates16.4.3. Using MM_LOENGLISH Mapping Mode16.5. Deleting and Moving Shapes16.6. Implementing a Context Menu16.6.1. Associating a Menu with a Class16.6.2. Choosing a Context Menu16.6.2.1. Identifying a Selected Element16.6.2.2. Exercising the Pop-Ups16.6.2.3. Checking the Context Menu Items16.6.3. Highlighting Elements16.6.3.1. Drawing Highlighted Elements16.6.3.2. Exercising the Highlights16.6.4. Servicing the Menu Messages16.6.4.1. Deleting an Element16.6.4.2. Moving an Element16.6.4.2.1. Modifying the WM_MOUSEMOVE Handler16.6.4.3. Getting the Elements to Move Themselves16.6.4.3.1. Dropping the Element16.6.4.4. Exercising the Application16.7. Dealing with Masked Elements16.8. Extending CLRSketcher16.8.1. Coordinate System Transformations16.8.2. Defining a Curve16.8.3. Defining a Sketch Class16.8.4. Drawing the Sketch in the Paint Event Handler16.8.5. Implementing Element Highlighting16.8.6. Creating Context Menus16.8.6.1. Implementing the Element Delete Operation16.8.6.2. Implementing the Send-To-Back operation16.8.6.3. Implementing the Element Move Operation16.8.6.4. Moving an Element16.9. Summary16.10. Exercises
17. Working with Dialogs and Controls
17.1. Understanding Dialogs17.2. Understanding Controls17.2.1. Common Controls17.3. Creating a Dialog Resource17.3.1. Adding Controls to a Dialog Box17.3.1.1. Testing the Dialog17.4. Programming for a Dialog17.4.1. Adding a Dialog Class17.4.2. Modal and Modeless Dialogs17.4.3. Displaying a Dialog17.4.3.1. Code to Display the Dialog17.4.3.2. Code to Close the Dialog17.5. Supporting the Dialog Controls17.5.1. Initializing the Controls17.5.2. Handling Radio Button Messages17.6. Completing Dialog Operations17.6.1. Adding Pen Widths to the Document17.6.2. Adding Pen Widths to the Elements17.6.3. Creating Elements in the View17.6.4. Exercising the Dialog17.7. Using a Spin Button Control17.7.1. Adding the Scale Menu Item and Toolbar Button17.7.2. Creating the Spin Button17.7.2.1. The Controls' Tab Sequence17.7.3. Generating the Scale Dialog Class17.7.3.1. Dialog Data Exchange and Validation17.7.3.2. Initializing the Dialog17.7.4. Displaying the Spin Button17.8. Using the Scale Factor17.8.1. Scaleable Mapping Modes17.8.2. Setting the Document Size17.8.3. Setting the Mapping Mode17.8.4. Implementing Scrolling with Scaling17.8.4.1. Setting Up the Scrollbars17.9. Working with Status Bars17.9.1. Adding a Status Bar to a Frame17.9.1.1. Defining the Status Bar Parts17.9.1.2. Updating the Status Bar17.10. Using a List Box17.10.1. Removing the Scale Dialog17.10.2. Creating a List Box Control17.10.2.1. Creating the Dialog Class17.10.2.2. Displaying the Dialog17.11. Using an Edit Box Control17.11.1. Creating an Edit Box Resource17.11.2. Creating the Dialog Class17.11.2.1. The CString Class17.11.3. Adding the Text Menu Item17.11.4. Defining a Text Element17.11.5. Implementing the CText Class17.11.5.1. The CText Constructor17.11.5.2. Drawing a CText Object17.11.5.3. Moving a CText Object17.11.6. Creating a Text Element17.12. Dialogs and Controls in CLR Sketcher17.12.1. Adding a Dialog17.12.1.1. Customizing the Dialog17.12.1.2. Displaying the Dialog17.12.1.3. Setting the Drawing Pen Width17.12.1.4. Using a Combo Box Control17.12.2. Creating Text Elements17.12.2.1. Drawing Text17.12.2.1.1. Creating Fonts17.12.2.1.2. Creating Brushes17.12.2.2. Choosing a Font17.12.2.3. Defining the Text Element Class17.12.2.4. Creating the Text Dialog17.12.2.4.1. Using a Text Box17.12.2.4.2. Displaying the Dialog and Creating a Text Element17.13. Summary17.14. Exercises
18. Storing and Printing Documents
18.1. Understanding Serialization18.2. Serializing a Document18.2.1. Serialization in the Document Class Definition18.2.2. Serialization in the Document Class Implementation18.2.2.1. The Serialize() Function18.2.2.2. The CArchive Class18.2.3. Functionality of CObject-Based Classes18.2.3.1. The Macros Adding Serialization to a Class18.2.4. How Serialization Works18.2.5. How to Implement Serialization for a Class18.3. Applying Serialization18.3.1. Recording Document Changes18.3.2. Serializing the Document18.3.3. Serializing the Element Classes18.3.3.1. The Serialize() Functions for the Shape Classes18.4. Exercising Serialization18.5. Moving Text18.6. Printing a Document18.6.1. The Printing Process18.6.1.1. The CPrintInfo Class18.7. Implementing Multipage Printing18.7.1. Getting the Overall Document Size18.7.2. Storing Print Data18.7.3. Preparing to Print18.7.4. Cleaning Up After Printing18.7.5. Preparing the Device Context18.7.6. Printing the Document18.7.7. Getting a Printout of the Document18.8. Serialization and Printing in CLR Sketcher18.8.1. Understanding Binary Serialization18.8.1.1. Dealing with Fields That Are Not Serializable18.8.1.2. Serializing an Object18.8.2. Serializing a Sketch18.8.2.1. Making the Sketch Class Serializable18.8.2.2. Implementing File Operations for a Sketch18.8.2.2.1. Creating Dialogs for File Operations18.8.2.2.2. Saving a Sketch18.8.2.2.3. Retrieving a Sketch from a File18.8.2.2.4. Implementing the Save As Operation18.8.3. Printing a Sketch18.8.3.1. Using the PrintDocument Component18.8.3.2. Implementing the Print Operation18.9. Summary18.10. Exercises
19. Writing Your Own DLLs
19.1. Understanding DLLs19.1.1. How DLLs Work19.1.1.1. Runtime Dynamic Linking19.1.2. Contents of a DLL19.1.2.1. The DLL Interface19.1.2.2. The DllMain() Function19.1.3. DLL Varieties19.1.3.1. MFC Extension DLL19.1.3.2. Regular DLL—Statically Linked to MFC19.1.3.3. Regular DLL—Dynamically Linked to MFC19.2. Deciding What to Put in a DLL19.3. Writing DLLs19.3.1. Writing and Using an Extension DLL19.3.1.1. Understanding DllMain()19.3.1.2. Adding Classes to the Extension DLL19.3.1.3. Exporting Classes from the Extension DLL19.3.1.4. Building a DLL19.3.1.5. Using the Extension DLL in Sketcher19.3.1.6. Files Required to Use a DLL19.3.2. Exporting Variables and Functions from a DLL19.3.3. Importing Symbols into a Program19.3.4. Implementing the Export of Symbols from a DLL19.3.4.1. Using Exported Symbols19.4. Summary19.5. Exercises
20. Connecting to Data Sources
20.1. Database Basics20.2. A Little SQL20.2.1. Retrieving Data Using SQL20.2.1.1. Choosing Records20.2.2. Joining Tables Using SQL20.2.3. Sorting Records20.3. Database Support in MFC20.3.1. MFC Classes Supporting ODBC20.4. Creating a Database Application20.4.1. Registering an ODBC Database20.4.2. Generating an MFC ODBC Program20.4.2.1. Snapshot versus Dynaset Recordsets20.4.3. Understanding the Program Structure20.4.3.1. Understanding Recordsets20.4.3.1.1. Recordset Creation20.4.3.1.2. Querying the Database20.4.3.1.3. Data Transfer between the Database and the Recordset20.4.3.2. Understanding the Record View20.4.3.3. Creating the View Dialog20.4.3.4. Linking the Controls to the Recordset20.4.4. Exercising the Example20.5. Sorting a Recordset20.5.1. Modifying the Window Caption20.6. Using a Second Recordset Object20.6.1. Adding a Recordset Class20.6.2. Adding a View Class for the Recordset20.6.2.1. Creating the Dialog Resource20.6.2.2. Creating the Record View Class20.6.3. Customizing the Recordset20.6.3.1. Adding a Filter to the Recordset20.6.3.2. Defining the Filter Parameter20.6.3.3. Initializing the Record View20.6.4. Accessing Multiple Table Views20.6.4.1. Switching Views20.6.4.2. Enabling the Switching Operation20.6.4.3. Handling View Activation20.6.5. Viewing Orders for a Product20.7. Viewing Customer Details20.7.1. Adding the Customer Recordset20.7.2. Creating the Customer Dialog Resource20.7.3. Creating the Customer View Class20.7.4. Adding a Filter20.7.5. Implementing the Filter Parameter20.7.6. Linking the Order Dialog to the Customer Dialog20.7.7. Exercising the Database Viewer20.8. Summary20.9. Exercises
21. Updating Data Sources
21.1. Update Operations21.1.1. CRecordset Update Operations21.1.1.1. Checking that Operations are Legal21.1.1.2. Record Locking21.1.2. Transactions21.1.2.1. CDatabase Transaction Operations21.2. A Simple Update Example21.2.1. Customizing the Application21.2.1.1. How It Works21.3. Managing the Update Process21.3.1. Implementing Update Mode21.3.1.1. Enabling and Disabling Edit Controls21.3.1.2. Changing the Button Label21.3.1.3. Controlling the Visibility of the Cancel Button21.3.1.4. Disabling the Record Menu21.3.1.5. Expediting the Update21.3.1.6. Implementing the Cancel Operation21.4. Adding Rows to a Table21.4.1. The Order Entry Process21.4.2. Creating the Resources21.4.3. Creating the Recordsets21.4.4. Creating the Recordset Views21.4.5. Adding Controls to the Dialog Resources21.4.6. Implementing Dialog Switching21.4.7. Creating an Order ID21.4.7.1. Storing the New Order ID21.4.7.2. Creating the New Order ID21.4.7.3. Initiating ID Creation21.4.8. Storing the Order Data21.4.8.1. Setting Dates21.4.9. Selecting Products for an Order21.4.10. Adding a New Order21.5. Summary21.6. Exercises
22. More on Windows Forms Applications
22.1. Creating the Application GUI22.1.1. Adding Submenus22.1.2. Adding a Tab Control22.1.3. Using GroupBox Controls22.1.4. Using Button Controls22.1.5. Using the WebBrowser Control22.1.6. Operation of the Winning Application22.1.7. Adding a Context Menu22.1.8. Creating Event Handlers22.1.8.1. Event Handlers for Menu Items22.1.8.2. Adding Members to the Form1 Class22.1.8.3. Handling the Play Menu Event22.1.9. Handling Events for the Limits Menu22.1.10. Creating a Dialog Box22.1.10.1. Adding a List to a ListBox22.1.10.2. Handling the Dialog Button Events22.1.10.3. Controlling the State of the ListBox Objects22.1.10.4. Creating the Dialog Object22.1.11. Using the Dialog Box22.1.11.1. Validating the Input22.1.11.2. Handling the Reset Menu Item Event22.1.12. Adding the Second Dialog22.1.12.1. Getting the Data from the Dialog Controls22.1.12.2. Disabling Input Controls22.1.12.3. Updating the Limits Menu Item Handlers22.1.13. Implementing the Help > About Menu Item22.1.14. Handling a Button Click22.1.15. Responding to the Context Menu22.1.15.1. The Logic for Dealing with the Choose Menu Item22.1.15.2. Creating the Dialog Form22.1.15.3. Developing the Dialog Class22.1.15.4. Handling the Click Event for the ChooseMenu22.2. Summary22.3. Exercises
23. Accessing Data Sources in a Windows Forms Application
23.1. Working with Data Sources23.2. Accessing and Displaying Data23.3. Using a DataGridView Control23.4. Using a DataGridView Control in Unbound Mode23.5. Customizing a DataGridView Control23.5.1. Customizing Header Cells23.5.2. Customizing Non-Header Cells23.5.2.1. Setting Up the Data23.5.2.2. Setting Up the Control23.5.2.3. Setting Up the Column Headers23.5.2.4. Formatting a Column23.5.2.5. Customizing Alternate Rows23.5.3. Dynamically Setting Cell Styles23.6. Using Bound Mode23.7. The BindingSource Component23.8. Using the BindingNavigator Control23.9. Binding to Individual Controls23.10. Working with Multiple Tables23.11. Summary23.12. Exercises
A. C++ Keywords
A.1. ISO/ANSI C++ KeywordsA.2. C++/CLI Keywords
B. ASCII Codes
C. Windows Message Types

Overview

Proudly presenting the latest edition of one of the all-time bestselling books on the C++ language, successful author Ivor Horton repeats the formula that has made each previous edition so popular by teaching you both the standard C++ language and C++/CLI as well as Visual C++ 2008. Thoroughly updated for the 2008 release, this book shows you how to build real-world applications using Visual C++ and guides you through the ins and outs of C++ development. With this book by your side, you are well on your way to becoming a successful C++ programmer.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9780470225905Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills