book

Ivor Horton's Beginning Visual C++® 2005

Name: Ivor Horton's Beginning Visual C++® 2005
Author: Ivor Horton
ISBN: 9780764571978

by Ivor Horton

February 2006

Beginner

1222 pages

33h 23m

English

Wrox

Read now

Unlock full access

Copyright
Credits
About the Author
Acknowledgments
Introduction
Who This Book Is ForWhat This Book CoversHow This Book Is StructuredWhat You Need to Use This BookConventionsHow it WorksSource CodeErratap2p.wrox.com
1. Programming with Visual C++ 2005
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. Console Applications1.4.4. 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.2. Modifying the Source Code1.6.4.3. Building the Solution1.6.4.4. Files Created by Building a Console Application1.6.5. Debug and Release Versions of Your Program1.6.5.1. Executing the Program1.6.5.2. Dealing with Errors1.6.6. Setting Options in Visual C++ 20051.6.7. Creating and Executing Windows Applications1.6.7.1. Creating an MFC Application1.6.7.2. Building and Executing the MFC Application1.6.8. 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.3.9. Specifying the Type for Enumeration Constants2.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.6.5. The Bitwise Operators2.6.5.1. The Bitwise AND2.6.5.2. The Bitwise OR2.6.5.3. The Bitwise Exclusive OR2.6.5.4. The Bitwise NOT2.6.5.5. The Bitwise Shift Operators2.7. Understanding Storage Duration and Scope2.7.1. Automatic Variables2.7.1.1. How it Works2.7.2. Positioning Variable Declarations2.7.3. Global Variables2.7.3.1. How it Works2.7.4. Static Variables2.8. Namespaces2.8.1. Declaring a Namespace2.8.2. Multiple Namespaces2.9. C++/CLI Programming2.9.1. C++/CLI Specific: Fundamental Data Types2.9.1.1. How it Works2.9.2. C++/CLI Output to the Command Line2.9.3. C++/CLI Specific — Formatting the Output2.9.3.1. How it Works2.9.4. C++/CLI Input from the Keyboard2.9.5. Using safe_cast2.9.6. C++/CLI Enumerations2.9.6.1. How it Works2.9.6.2. Specifying a Type for Enumeration Constants2.9.6.3. Specifying Values for Enumeration Constants2.10. Summary2.11. 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.3. The Extended if Statement3.1.3.1. How It Works3.1.4. Nested if-else Statements3.1.5. Logical Operators and Expressions3.1.5.1. Logical AND3.1.5.2. Logical OR3.1.5.3. Logical NOT3.1.5.4. How It Works3.1.6. The Conditional Operator3.1.6.1. How It Works3.1.7. The switch Statement3.1.7.1. How It Works3.1.7.2. How It Works3.1.8. 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. Hndling 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. Dnamic Allocation of Multidimensional Arrays4.4. Using References4.4.1. What Is a Reference?4.4.2. Declaring and Initializing References4.5. C++/CLI Programming4.5.1. Tracking Handles4.5.1.1. Declaring Tracking Handles4.5.2. CLR Arrays4.5.2.1. How It Works4.5.2.2. Sorting One-Dimensional Arrays4.5.2.3. How It Works4.5.2.4. Searching One-Dimensional Arrays4.5.2.5. How It Works4.5.2.6. Multidimensional Arrays4.5.2.7. How It Works4.5.2.8. Arrays of Arrays4.5.2.9. How It Works4.5.3. Strings4.5.3.1. Joining Strings4.5.3.2. How It Works4.5.3.3. Modifying Strings4.5.3.4. Searching Strings4.5.3.5. How It Works4.5.4. Tracking References4.5.5. Interior Pointers4.5.5.1. How It Works4.6. Summary4.7. 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 Multi-Dimensional 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.4.2. Use of the const Modifier5.2.4.3. How It Works5.2.4.4. Arguments to main()5.2.4.5. How It Works5.2.5. Accepting a Variable Number of Function Arguments5.2.5.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.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. Class Properties7.11.3.1. Defining Scalar Properties7.11.3.2. Trivial Scalar Properties7.11.3.3. How It Works7.11.3.4. Defining Indexed Properties7.11.3.5. How It Works7.11.3.6. More Complex Indexed Properties7.11.3.7. Static Properties7.11.3.8. Reserved Property Names7.11.4. initonly Fields7.11.5. 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 an 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.4. Defining the CBox Class8.6.4.1. Adding Data Members8.6.4.2. Defining the Constructor8.6.4.3. Adding Function Members8.6.4.4. Adding Global Functions8.6.4.5. Using Our CBox Class8.7. Organizing Your Program Code8.7.1. Naming Program Files8.8. C++/CLI Programming8.8.1. Overloading Operators in Value Classes8.8.1.1. How It Works8.8.2. Overloading the Increment and Decrement Operators8.8.3. Overloading Operators in Reference Classes8.8.3.1. How It Works8.9. Summary8.10. 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. Inheritance in C++/CLI Classes9.9.1.1. How It Works9.9.2. Interface Classes9.9.3. Defining Interface Classes9.9.3.1. How It Works9.9.4. Classes and Assemblies9.9.4.1. Visibility Specifiers for Classes and Interfaces9.9.4.2. Access Specifiers for Class and Interface Members9.9.5. Functions Specified as new9.9.6. Delegates and Events9.9.6.1. Declaring Delegates9.9.6.2. Creating Delegates9.9.6.3. How It Works9.9.6.4. Unbound Delegates9.9.6.5. How It Works9.9.6.6. Creating Events9.9.6.7. How It Works9.9.7. Destructors and Finalizers in Reference Classes9.9.7.1. How It Works9.9.8. Generic Classes9.9.8.1. How It Works9.9.8.2. Generic Interface Classes9.9.8.3. Generic Collection Classes9.9.8.3.1. List<T> — A Generic List9.9.8.3.2. LinkedList<T> — A Generic Doubly Linked List9.9.8.3.3. Dictionary<TKey, TValue> — A Generic Dictionary Storing Key/Value Pairs9.9.8.4. How It Works9.10. Summary9.11. Exercises
10. Debugging Techniques
10.1. Understanding Debugging10.1.1. Program Bugs10.1.2. Common Bugs10.2. Basic Debugging Operations10.2.1. Setting Breakpoints10.2.1.1. Advanced Breakpoints10.2.2. Setting Tracepoints10.2.3. Starting Debugging10.2.3.1. Inspecting Variable Values10.2.3.2. Viewing Variables in the Edit Window10.2.4. Changing the Value of a Variable10.3. Adding Debugging Code10.3.1. Using Assertions10.3.2. Adding Your Own Debugging Code10.3.2.1. How it works10.4. Debugging a Program10.4.1. The Call Stack10.4.2. Step Over to the Error10.5. Testing the Extended Class10.5.1. Finding the Next Bug10.6. Debugging Dynamic Memory10.6.1. Functions Checking the Free Store10.6.2. Controlling Free Store Debug Operations10.6.3. Free Store Debugging Output10.6.3.1. How it works10.7. Debugging C++/CLI Programs10.7.1. Using the Debug and Trace Classes10.7.1.1. Generating Output10.7.1.2. Setting the Output Destination10.7.1.3. Indenting the Output10.7.1.4. Controlling Output10.7.1.5. Assertions10.7.1.6. How it works10.8. Summary
11. Windows Programming Concepts
11.1. Windows Programming Basics11.1.1. Elements of a Window11.1.2. Windows Programs and the Operating System11.1.3. Event-Driven Programs11.1.4. Windows Messages11.1.5. The Windows API11.1.6. Windows Data Types11.1.7. Notation in Windows Programs11.2. The Structure of a Windows Program11.2.1. The WinMain() Function11.2.1.1. Specifying a Program Window11.2.1.2. Creating a Program Window11.2.1.3. Initializing the Program Window11.2.1.4. Dealing with Windows Messages11.2.1.4.1. Queued and Non-Queued Messages11.2.1.4.2. The Message Loop11.2.1.4.3. Multitasking11.2.1.5. A Complete WinMain() Function11.2.1.6. How It Works11.2.2. Message Processing Functions11.2.2.1. The WindowProc() Function11.2.2.2. Decoding a Windows Message11.2.2.2.1. Drawing the Window Client Area11.2.2.3. Ending the Program11.2.2.4. A Complete WindowProc() Function11.2.2.5. How It Works11.2.3. A Simple Windows Program11.3. Windows Program Organization11.4. The Microsoft Foundation Classes11.4.1. MFC Notation11.4.2. How an MFC Program Is Structured11.4.2.1. The Application Class11.4.2.2. The Window Class11.4.2.3. Completing the Program11.4.2.4. The Finished Product11.5. Using Windows Forms11.6. Summary
12. Windows Programming with the Microsoft Foundation Classes
12.1. The Document/View Concept in MFC12.1.1. What Is a Document?12.1.2. Document Interfaces12.1.3. What Is a View?12.1.4. Linking a Document and Its Views12.1.4.1. Document Templates12.1.4.2. Document Template Classes12.1.5. Your Application and MFC12.2. Creating MFC Applications12.2.1. Creating an SDI Application12.2.2. The Output from the MFC Application Wizard12.2.2.1. Viewing Project Files12.2.2.2. Viewing Classes12.2.2.3. The Class Definitions12.2.2.4. Creating an Executable Module12.2.2.4.1. Precompiled Header Files12.2.2.5. Running the Program12.2.2.6. How the Program Works12.2.2.6.1. The InitInstance() Function12.2.2.6.2. The Run() Function12.2.3. Creating an MDI Application12.2.3.1. Running the Program12.3. Summary12.4. Exercises
13. Working with Menus and Toolbars
13.1. Communicating with Windows13.1.1. Understanding Message Maps13.1.1.1. Message Handler Definitions13.1.2. Message Categories13.1.3. Handling Messages in Your Program13.1.3.1. How Command Messages Are Processed13.2. Extending the Sketcher Program13.3. Elements of a Menu13.3.1. Creating and Editing Menu Resources13.3.1.1. Adding a Menu Item to the Menu Bar13.3.1.2. Adding Items to the Element Menu13.3.1.3. Modifying Existing Menu Items13.3.1.4. Completing the Menu13.4. Adding Handlers for Menu Messages13.4.1. Choosing a Class to Handle Menu Messages13.4.2. Creating Menu Message Functions13.4.3. Coding Menu Message Functions13.4.3.1. Adding Members to Store Color and Element Mode13.4.3.2. Initializing the New Class Data Members13.4.3.2.1. Modifying the Class Constructor13.4.3.3. Running the Extended Example13.4.4. Adding Message Handlers to Update the User Interface13.4.4.1. Coding a Command Update Handler13.4.4.2. Exercising the Update Handlers13.5. Adding Toolbar Buttons13.5.1. Editing Toolbar Button Properties13.5.2. Exercising the Toolbar Buttons13.5.3. Adding Tooltips13.6. Summary13.7. Exercises
14. Drawing in a Window
14.1. Basics of Drawing in a Window14.1.1. The Window Client Area14.1.2. The Windows Graphical Device Interface14.1.2.1. What Is a Device Context?14.1.2.2. Mapping Modes14.2. The Drawing Mechanism in Visual C++14.2.1. The View Class in Your Application14.2.1.1. The OnDraw() Member Function14.2.2. The CDC Class14.2.2.1. Displaying Graphics14.2.2.1.1. Drawing Lines14.2.2.1.2. Drawing Circles14.2.2.2. Drawing in Color14.2.2.2.1. Creating a Pen14.2.2.2.2. Using a Pen14.2.2.2.3. Creating a Brush14.2.2.2.4. Using a Brush14.3. Drawing Graphics in Practice14.4. Programming the Mouse14.4.1. Messages from the Mouse14.4.1.1. WM_LBUTTONDOWN14.4.1.2. WM_MOUSEMOVE14.4.1.3. WM_LBUTTONUP14.4.2. Mouse Message Handlers14.4.3. Drawing Using the Mouse14.4.3.1. Getting the Client Area Redrawn14.4.3.2. Defining Classes for Elements14.4.3.2.1. Storing a Temporary Element in the View14.4.3.3. The CElement Class14.4.3.4. The CLine Class14.4.3.4.1. Implementing the CLine Class14.4.3.4.2. The CLine Class Constructor14.4.3.4.3. Drawing a Line14.4.3.4.4. Creating Bounding Rectangles14.4.3.4.5. Normalized Rectangles14.4.3.5. Calculating the Enclosing Rectangle for a Line14.4.3.6. The CRectangle Class14.4.3.6.1. The CRectangle Class Constructor14.4.3.6.2. Drawing a Rectangle14.4.3.7. The CCircle Class14.4.3.7.1. Implementing the CCircle Class14.4.3.7.2. The CCircle Class Constructor14.4.3.7.3. Drawing a Circle14.4.3.8. The CCurve Class14.4.3.9. Completing the Mouse Message Handlers14.4.3.9.1. Setting the Drawing Mode14.4.3.9.2. Coding the OnMouseMove() Handler14.4.3.9.3. Creating an Element14.4.3.9.4. Dealing with WM_LBUTTONUP Messages14.5. Exercising Sketcher14.5.1. Running the Example14.5.2. Capturing Mouse Messages14.6. Summary14.7. Exercises
15. Creating the Document and Improving the View
15.1. What Are Collection Classes?15.1.1. Types of Collection15.1.2. The Type-Safe Collection Classes15.1.3. Collections of Objects15.1.3.1. The CArray Template Class15.1.3.2. Helper Functions15.1.3.3. The CList Template Class15.1.3.3.1. Adding Elements to a List15.1.3.3.2. Iterating through a List15.1.3.3.3. Searching a List15.1.3.3.4. Deleting Objects from a List15.1.3.3.5. Helper Functions for a List15.1.3.4. The CMap Template Class15.1.3.4.1. Helper Functions Used by CMap15.1.4. The Typed Pointer Collections15.1.4.1. The CTypedPtrList Template Class15.1.4.2. CTypePtrList Operations15.2. Using the CList Template Class15.2.1. Drawing a Curve15.2.2. Defining the CCurve Class15.2.3. Implementing the CCurve Class15.2.4. Exercising the CCurve Class15.3. Creating the Document15.3.1. Using a CTypedPtrList Template15.3.1.1. Implementing the Document Destructor15.3.1.2. Drawing the Document15.3.1.3. Adding an Element to the Document15.3.1.4. Exercising the Document15.4. Improving the View15.4.1. Updating Multiple Views15.4.2. Scrolling Views15.4.2.1. Logical Coordinates and Client Coordinates15.4.2.2. Dealing with Client Coordinates15.4.3. Using MM_LOENGLISH Mapping Mode15.5. Deleting and Moving Shapes15.6. Implementing a Context Menu15.6.1. Associating a Menu with a Class15.6.2. Choosing a Context Menu15.6.2.1. Identifying a Selected Element15.6.2.2. Exercising the Pop-Ups15.6.2.3. Checking the Context Menu Items15.6.3. Highlighting Elements15.6.3.1. Drawing Highlighted Elements15.6.3.2. Exercising the Highlights15.6.4. Servicing the Menu Messages15.6.4.1. Deleting an Element15.6.4.2. Moving an Element15.6.4.2.1. Modifying the WM_MOUSEMOVE Handler15.6.4.3. Getting the Elements to Move Themselves15.6.4.3.1. Dropping the Element15.6.4.4. Exercising the Application15.7. Dealing with Masked Elements15.8. Summary15.9. Exercises
16. Working with Dialogs and Controls
16.1. Understanding Dialogs16.2. Understanding Controls16.2.1. Common Controls16.3. Creating a Dialog Resource16.3.1. Adding Controls to a Dialog Box16.3.1.1. Testing the Dialog16.4. Programming for a Dialog16.4.1. Adding a Dialog Class16.4.2. Modal and Modeless Dialogs16.4.3. Displaying a Dialog16.4.3.1. Code to Display the Dialog16.4.3.2. Code to Close the Dialog16.5. Supporting the Dialog Controls16.5.1. Initializing the Controls16.5.2. Handling Radio Button Messages16.6. Completing Dialog Operations16.6.1. Adding Pen Widths to the Document16.6.2. Adding Pen Widths to the Elements16.6.3. Creating Elements in the View16.6.4. Exercising the Dialog16.7. Using a Spin Button Control16.7.1. Adding the Scale Menu Item and Toolbar Button16.7.2. Creating the Spin Button16.7.2.1. The Controls' Tab Sequence16.7.3. Generating the Scale Dialog Class16.7.3.1. Dialog Data Exchange and Validation16.7.3.2. Initializing the Dialog16.7.4. Displaying the Spin Button16.8. Using the Scale Factor16.8.1. Scaleable Mapping Modes16.8.2. Setting the Document Size16.8.3. Setting the Mapping Mode16.8.4. Implementing Scrolling with Scaling16.8.4.1. Setting Up the Scrollbars16.9. Working with Status Bars16.9.1. Adding a Status Bar to a Frame16.9.1.1. Defining the Status Bar Parts16.9.1.2. Updating the Status Bar16.10. Using a List Box16.10.1. Removing the Scale Dialog16.10.2. Creating a List Box Control16.10.2.1. Creating the Dialog Class16.10.2.2. Displaying the Dialog16.11. Using an Edit Box Control16.11.1. Creating an Edit Box Resource16.11.2. Creating the Dialog Class16.11.2.1. The CString Class16.11.3. Adding the Text Menu Item16.11.4. Defining a Text Element16.11.5. Implementing the CText Class16.11.5.1. The CText Constructor16.11.5.2. Drawing a CText Object16.11.5.3. Moving a CText Object16.11.6. Creating a Text Element16.12. Summary16.13. Exercises
17. Storing and Printing Documents
17.1. Understanding Serialization17.2. Serializing a Document17.2.1. Serialization in the Document Class Definition17.2.2. Serialization in the Document Class Implementation17.2.2.1. The Serialize() Function17.2.2.2. The CArchive Class17.2.3. Functionality of CObject-Based Classes17.2.3.1. The Macros Adding Serialization to a Class17.2.4. How Serialization Works17.2.5. How to Implement Serialization for a Class17.3. Applying Serialization17.3.1. Recording Document Changes17.3.2. Serializing the Document17.3.3. Serializing the Element Classes17.3.3.1. The Serialize() Functions for the Shape Classes17.4. Exercising Serialization17.5. Moving Text17.6. Printing a Document17.6.1. The Printing Process17.6.1.1. The CPrintInfo Class17.7. Implementing Multipage Printing17.7.1. Getting the Overall Document Size17.7.2. Storing Print Data17.7.3. Preparing to Print17.7.4. Cleaning Up After Printing17.7.5. Preparing the Device Context17.7.6. Printing the Document17.7.7. Getting a Printout of the Document17.8. Summary17.9. Exercises
18. Writing Your Own DLLs
18.1. Understanding DLLs18.1.1. How DLLs Work18.1.1.1. Run-Time Dynamic Linking18.1.2. Contents of a DLL18.1.2.1. The DLL Interface18.1.2.2. The DllMain() Function18.1.3. DLL Varieties18.1.3.1. MFC Extension DLL18.1.3.2. Regular DLL—Statically Linked to MFC18.1.3.3. Regular DLL—Dynamically Linked to MFC18.2. Deciding What to Put in a DLL18.3. Writing DLLs18.3.1. Writing and Using an Extension DLL18.3.1.1. Understanding DllMain()18.3.1.2. Adding Classes to the Extension DLL18.3.1.3. Exporting Classes from the Extension DLL18.3.1.4. Building a DLL18.3.1.5. Using the Extension DLL in Sketcher18.3.1.6. Files Required to Use a DLL18.3.2. Exporting Variables and Functions from a DLL18.3.3. Importing Symbols into a Program18.3.4. Implementing the Export of Symbols from a DLL18.3.4.1. Using Exported Symbols18.4. Summary18.5. Exercises
19. Connecting to Data Sources
19.1. Database Basics19.2. A Little SQL19.2.1. Retrieving Data Using SQL19.2.1.1. Choosing Records19.2.2. Joining Tables Using SQL19.2.3. Sorting Records19.3. Database Support in MFC19.3.1. MFC Classes Supporting ODBC19.4. Creating a Database Application19.4.1. Registering an ODBC Database19.4.2. Generating an MFC ODBC Program19.4.2.1. Snapshot versus Dynaset Recordsets19.4.3. Understanding the Program Structure19.4.3.1. Understanding Recordsets19.4.3.1.1. Recordset Creation19.4.3.1.2. Querying the Database19.4.3.1.3. Data Transfer between the Database and the Recordset19.4.3.2. Understanding the Record View19.4.3.3. Creating the View Dialog19.4.3.4. Linking the Controls to the Recordset19.4.4. Exercising the Example19.5. Sorting a Recordset19.5.1. Modifying the Window Caption19.6. Using a Second Recordset Object19.6.1. Adding a Recordset Class19.6.2. Adding a View Class for the Recordset19.6.2.1. Creating the Dialog Resource19.6.2.2. Creating the Record View Class19.6.3. Customizing the Recordset19.6.3.1. Adding a Filter to the Recordset19.6.3.2. Defining the Filter Parameter19.6.3.3. Initializing the Record View19.6.4. Accessing Multiple Table Views19.6.4.1. Switching Views19.6.4.2. Enabling the Switching Operation19.6.4.3. Handling View Activation19.6.5. Viewing Orders for a Product19.7. Viewing Customer Details19.7.1. Adding the Customer Recordset19.7.2. Creating the Customer Dialog Resource19.7.3. Creating the Customer View Class19.7.4. Adding a Filter19.7.5. Implementing the Filter Parameter19.7.6. Linking the Order Dialog to the Customer Dialog19.7.7. Exercising the Database Viewer19.8. Summary19.9. Exercises
20. Updating Data Sources
20.1. Update Operations20.1.1. CRecordset Update Operations20.1.1.1. Checking that Operations are Legal20.1.1.2. Record Locking20.1.2. Transactions20.1.2.1. CDatabase Transaction Operations20.2. A Simple Update Example20.2.1. Customizing the Application20.3. Managing the Update Process20.3.1. Implementing Update Mode20.3.1.1. Enabling and Disabling Edit Controls20.3.1.2. Changing the Button Label20.3.1.3. Controlling the Visibility of the Cancel Button20.3.1.4. Disabling the Record Menu20.3.1.5. Expediting the Update20.3.1.6. Implementing the Cancel Operation20.4. Adding Rows to a Table20.4.1. The Order Entry Process20.4.2. Creating the Resources20.4.3. Creating the Recordsets20.4.4. Creating the Recordset Views20.4.5. Adding Controls to the Dialog Resources20.4.6. Implementing Dialog Switching20.4.7. Creating an Order ID20.4.7.1. Storing the New Order ID20.4.7.2. Creating the New Order ID20.4.7.3. Initiating ID Creation20.4.8. Storing the Order Data20.4.8.1. Setting Dates20.4.9. Selecting Products for an Order20.4.10. Adding a New Order20.5. Summary20.6. Exercises
21. Applications Using Windows Forms
21.1. Understanding Windows Forms21.2. Understanding Windows Forms Applications21.2.1. Modifying the Properties of a Form21.2.2. How the Application Starts21.3. Customizing the Application GUI21.3.1. Adding Controls to a Form21.3.1.1. Adding Menus21.3.1.2. Adding Submenus21.3.2. Adding a Tab Control21.3.3. Using GroupBox Controls21.3.4. Using Button Controls21.3.5. Using the WebBrowser Control21.3.6. Operation of the Winning Application21.3.7. Adding a Context Menu21.3.8. Creating Event Handlers21.3.8.1. Event Handlers for Menu Items21.3.8.2. Adding Members to the Form1 Class21.3.8.3. Handling the Play Menu Event21.3.9. Handling Events for the Limits Menu21.3.10. Creating a Dialog Box21.3.10.1. Adding a List to a ListBox21.3.10.2. Handling the Dialog Button Events21.3.10.3. Controlling the State of the ListBox Objects21.3.10.4. Creating the Dialog Object21.3.11. Using the Dialog Box21.3.11.1. Validating the Input21.3.11.2. Handler the Reset Menu Item Event21.3.12. Adding the Second Dialog21.3.12.1. Getting the Data from the Dialog Controls21.3.12.2. Disabling Input Controls21.3.12.3. Updating the Limits Menu Item Handlers21.3.13. Implementing the Help | About Menu Item21.3.14. Handling a Button Click21.3.15. Responding to the Context Menu21.3.15.1. The Logic for Dealing with the Choose Menu Item21.3.15.2. Creating the Dialog Form21.3.15.3. Developing the Dialog Class21.3.15.4. Handling the Click Event for the ChooseMenu21.4. Summary21.5. Exercises
22. Accessing Data Sources in a Windows Forms Application
22.1. Working with Data Sources22.2. Accessing and Displaying Data22.3. Using a DataGridView Control22.4. Using a DataGridView Control in Unbound Mode22.5. Customizing a DataGridView Control22.5.1. Customizing Header Cells22.5.2. Customizing Non-Header Cells22.5.2.1. Setting Up the Data22.5.2.2. Setting Up the Control22.5.2.3. Setting Up the Column Headers22.5.2.4. Formatting a Column22.5.2.5. Customizing Alternate Rows22.5.3. Dynamically Setting Cell Styles22.6. Using Bound Mode22.7. The BindingSource Component22.8. Using the BindingNavigator Control22.9. Binding to Individual Controls22.10. Working with Multiple Tables22.11. Summary22.12. Exercises
A. C++ Keywords
A.1. ISO/ANSI C++ KeywordsA.2. C++/CLI Keywords
B. ASCII Codes

Content preview from Ivor Horton's Beginning Visual C++® 2005

Introduction

Welcome to Beginning Visual C++ 2005. With this book you can become an effective C++ programmer. The latest development system from Microsoft, Visual Studio 2005, supports two distinct but closely related flavors of the C++ language; it fully supports the original ISO/ANSI standard C++, and you also get support for a new version of C++ called C++/CLI that was developed by Microsoft but is now an ECMA standard. These two versions of C++ are complementary and fulfill different roles. ISO/ANSI C++ is there for the development of high-performance applications that run natively on your computer whereas C++/CLI has been developed specifically for the .NET Framework. This book will teach you the essentials of programming applications in both versions of C++.

You get quite a lot of assistance from automatically generated code when writing ISO/ANSI C++ programs, but you still need to write a lot of C++ yourself. You need a solid understanding of object-oriented programming techniques, as well as a good appreciation of what's involved in programming for Windows. Although C++/CLI targets the .NET Framework, it also is the vehicle for the development of Windows Forms applications that you can develop with little or in some cases no, explicit code writing. Of course, when you do have to add code to a Windows Forms application, even though it may be a very small proportion of the total, you still need an in-depth knowledge of the C++/CLI language.

ISO/ANSI C++ remains the language ...

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

Ivor Horton's Beginning Visual C++® 2010

Publisher Resources

ISBN: 9780764571978Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Ivor Horton's Beginning Visual C++® 2005

by Ivor Horton

Introduction

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.