book

Ivor Horton's Beginning Visual C++® 2010

Name: Ivor Horton's Beginning Visual C++® 2010
Author: Ivor Horton
ISBN: 9780470500880

by Ivor Horton

April 2010

Beginner

1271 pages

34h 36m

English

Wrox

Read now

Unlock full access

Copyright
ABOUT THE AUTHOR
ABOUT THE TECHNICAL EDITOR
CREDITS
ACKNOWLEDGMENTS
INTRODUCTION
PROGRAMMING IN C++DEVELOPING WINDOWS APPLICATIONSADVANCED LIBRARY CAPABILITIESWHO THIS BOOK IS FORWHAT THIS BOOK COVERSHOW THIS BOOK IS STRUCTUREDWHAT YOU NEED TO USE THIS BOOKCONVENTIONSSOURCE CODEERRATAP2P.WROX.COM
1. Programming With Visual C++ 2010
1.1. THE .NET FRAMEWORK1.2. THE COMMON LANGUAGE RUNTIME1.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. The Editor1.5.2. The Compiler1.5.3. The Linker1.5.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.4.5. Debug and Release Versions of Your Program1.6.4.6. Executing the Program1.6.4.7. Dealing with Errors1.6.5. Setting Options in Visual C++ 20101.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/IEC 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.3. Formatting the Output2.4.4. Escape Sequences2.5. CALCULATING IN C++2.5.1. The Assignment Statement2.5.2. Arithmetic Operations2.5.2.1. The const Modifier2.5.2.2. Constant Expressions2.5.2.3. Program Input2.5.2.4. Calculating the Result2.5.2.5. Displaying the Result2.5.3. Calculating a Remainder2.5.4. Modifying a Variable2.5.5. The Increment and Decrement Operators2.5.6. The Sequence of Calculation2.5.6.1. Operator Precedence2.6. TYPE CONVERSION AND CASTING2.6.1. Type Conversion in Assignments2.6.2. Explicit Type Conversion2.6.3. Old-Style Casts2.7. THE AUTO KEYWORD2.8. DISCOVERING TYPES2.9. THE BITWISE OPERATORS2.9.1. The Bitwise AND2.9.2. The Bitwise OR2.9.3. The Bitwise Exclusive OR2.9.4. The Bitwise NOT2.9.5. The Bitwise Shift Operators2.10. INTRODUCING LVALUES AND RVALUES2.11. UNDERSTANDING STORAGE DURATION AND SCOPE2.11.1. Automatic Variables2.11.2. Positioning Variable Declarations2.11.3. Global Variables2.11.4. Static Variables2.12. NAMESPACES2.12.1. Declaring a Namespace2.12.2. Multiple Namespaces2.13. C++/CLI PROGRAMMING2.13.1. C++/CLI Specific: Fundamental Data Types2.13.2. C++/CLI Output to the Command Line2.13.3. C++/CLI Specific — Formatting the Output2.13.4. C++/CLI Input from the Keyboard2.13.5. Using safe_cast2.13.6. C++/CLI Enumerations2.13.6.1. Specifying a Type for Enumeration Constants2.13.6.2. Specifying Values for Enumeration Constants2.13.6.3. Operations on Enumeration Constants2.13.6.4. Using Enumerators as Flags2.13.6.5. Native Enumerations in a C++/CLI Program2.14. DISCOVERING C++/CLI TYPES2.15. SUMMARY
3. Decisions and Loops
3.1. COMPARING VALUES3.1.1. The if Statement3.1.2. Nested if Statements3.1.2.1. The Extended if Statement3.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.5. The Conditional Operator3.1.6. The switch Statement3.1.7. Unconditional Branching3.2. REPEATING A BLOCK OF STATEMENTS3.2.1. What Is a Loop?3.2.2. Variations on the for Loop3.2.2.1. Using the continue Statement3.2.2.2. Floating-Point Loop Counters3.2.3. The while Loop3.2.4. The do-while Loop3.2.5. Nested Loops3.3. C++/CLI PROGRAMMING3.3.1. The for each Loop3.4. SUMMARY
4. Arrays, Strings, and Pointers
4.1. HANDLING MULTIPLE DATA VALUES OF THE SAME TYPE4.1.1. Arrays4.1.2. Declaring Arrays4.1.3. Initializing Arrays4.1.4. Character Arrays and String Handling4.1.4.1. String Input4.1.5. Multidimensional Arrays4.1.5.1. Initializing Multidimensional Arrays4.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.4. Initializing Pointers4.2.4.1. Pointers to char4.2.5. The sizeof Operator4.2.6. Constant Pointers and Pointers to Constants4.2.7. Pointers and Arrays4.2.7.1. Pointer Arithmetic4.2.7.2. Using Pointers with Multidimensional Arrays4.2.7.3. 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.4. Dynamic Allocation of Multidimensional Arrays4.4. USING REFERENCES4.4.1. What Is a Reference?4.4.2. Declaring and Initializing Lvalue References4.4.3. Defining and Initializing Rvalue 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.6. C++/CLI PROGRAMMING4.6.1. Tracking Handles4.6.1.1. Creating Tracking Handles4.6.2. CLR Arrays4.6.2.1. Sorting One-Dimensional Arrays4.6.2.2. Searching One-Dimensional Arrays4.6.2.3. Multidimensional Arrays4.6.2.4. Arrays of Arrays4.6.3. Strings4.6.3.1. Joining Strings4.6.3.2. Modifying Strings4.6.3.3. Comparing Strings4.6.3.4. Searching Strings4.6.4. Tracking References4.6.5. Interior Pointers4.7. SUMMARY

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.2. PASSING ARGUMENTS TO A FUNCTION5.2.1. The Pass-by-value Mechanism5.2.2. Pointers as Arguments to a Function5.2.3. Passing Arrays to a Function5.2.3.1. Passing Multidimensional Arrays to a Function5.2.4. References as Arguments to a Function5.2.5. Use of the const Modifier5.2.6. Rvalue Reference Parameters5.2.7. Arguments to main()5.2.8. Accepting a Variable Number of Function Arguments5.3. RETURNING VALUES FROM A FUNCTION5.3.1. Returning a Pointer5.3.1.1. A Cast-Iron Rule for Returning Addresses5.3.2. Returning a Reference5.3.2.1. A Teflon-Coated Rule: Returning References5.3.3. Static Variables in a Function5.4. RECURSIVE FUNCTION CALLS5.4.1. Using Recursion5.5. C++/CLI PROGRAMMING5.5.1. Functions Accepting a Variable Number of Arguments5.5.2. Arguments to main()5.6. SUMMARY
6. More about Program Structure
6.1. POINTERS TO FUNCTIONS6.1.1. Declaring Pointers to Functions6.1.2. A Pointer to a Function as an Argument6.1.3. Arrays of Pointers to Functions6.2. INITIALIZING FUNCTION PARAMETERS6.3. EXCEPTIONS6.3.1. Throwing Exceptions6.3.2. Catching Exceptions6.3.3. Exception Handling in the MFC6.4. HANDLING MEMORY ALLOCATION ERRORS6.5. FUNCTION OVERLOADING6.5.1. What Is Function Overloading?6.5.2. Reference Types and Overload Selection6.5.3. When to Overload Functions6.6. FUNCTION TEMPLATES6.6.1. Using a Function Template6.7. USING THE DECLTYPE OPERATOR6.8. AN EXAMPLE USING FUNCTIONS6.8.1. Implementing a Calculator6.8.1.1. Analyzing the Problem6.8.2. Eliminating Blanks from a String6.8.2.1. How the Function Functions6.8.3. Evaluating an Expression6.8.3.1. How the Function Functions6.8.4. Getting the Value of a Term6.8.4.1. How the Function Functions6.8.5. Analyzing a Number6.8.5.1. How the Function Functions6.8.6. Putting the Program Together6.8.6.1. How the Function Functions6.8.7. Extending the Program6.8.7.1. How the Function Functions6.8.8. Extracting a Substring6.8.8.1. How the Function Functions6.8.9. Running the Modified Program6.9. C++/CLI PROGRAMMING6.9.1. Understanding Generic Functions6.9.1.1. Defining Generic Functions6.9.1.2. Using Generic Functions6.9.2. A Calculator Program for the CLR6.9.2.1. Removing Spaces from the Input String6.9.2.2. Evaluating an Arithmetic Expression6.9.2.3. Obtaining the Value of a Term6.9.2.4. Evaluating a Number6.9.2.5. Extracting a Parenthesized Substring6.10. SUMMARY
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.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.4. Member Functions of a Class7.3.5. Positioning a Member Function Definition7.3.6. Inline Functions7.4. CLASS CONSTRUCTORS7.4.1. What is a Constructor?7.4.2. The Default Constructor7.4.3. Assigning Default Parameter Values in a Class7.4.4. Using an Initialization List in a Constructor7.4.5. Making a Constructor Explicit7.5. PRIVATE MEMBERS OF A CLASS7.5.1. Accessing private Class Members7.5.2. The friend Functions of a Class7.5.2.1. Placing friend Function Definitions Inside the Class7.5.3. The Default Copy Constructor7.6. THE POINTER this7.7. CONST OBJECTS7.7.1. const Member Functions of a Class7.7.2. Member Function Definitions Outside the Class7.8. ARRAYS OF OBJECTS7.9. STATIC MEMBERS OF A CLASS7.9.1. Static Data Members7.9.2. Static Function Members of a Class7.10. POINTERS AND REFERENCES TO CLASS OBJECTS7.10.1. Pointers to Objects7.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. The ToString() Function in a Class7.11.1.2. Literal Fields7.11.2. Defining Reference Class Types7.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. Defining Indexed Properties7.11.4.4. More Complex Indexed Properties7.11.4.5. Static Properties7.11.4.6. Reserved Property Names7.11.5. initonly Fields7.11.6. Static Constructors7.12. SUMMARY
8. More on Classes
8.1. CLASS DESTRUCTORS8.1.1. What Is a Destructor?8.1.2. The Default Destructor8.1.3. Destructors and Dynamic Memory Allocation8.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.2. Implementing Full Support for a Comparison Operator8.4.3. Overloading the Assignment Operator8.4.3.1. Fixing the Problem8.4.4. Overloading the Addition Operator8.4.5. Overloading the Increment and Decrement Operators8.4.6. Overloading the Function Call Operator8.5. THE OBJECT COPYING PROBLEM8.5.1. Avoiding Unnecessary Copy Operations8.5.2. Applying Rvalue Reference Parameters8.5.3. Named Objects are Lvalues8.6. CLASS TEMPLATES8.6.1. Defining a Class Template8.6.1.1. Template Member Functions8.6.2. Creating Objects from a Class Template8.6.3. Class Templates with Multiple Parameters8.6.4. Templates for Function Objects8.7. USING CLASSES8.7.1. The Idea of a Class Interface8.7.2. Defining the Problem8.7.3. Implementing the CBox Class8.7.3.1. Comparing CBox Objects8.7.3.2. Combining CBox Objects8.7.3.3. Analyzing CBox Objects8.8. ORGANIZING YOUR PROGRAM CODE8.8.1. Naming Program Files8.9. NATIVE C++ LIBRARY CLASSES FOR STRINGS8.9.1. Creating String Objects8.9.2. Concatenating Strings8.9.3. Accessing and Modifying Strings8.9.4. Comparing Strings8.9.5. Searching Strings8.10. C++/CLI PROGRAMMING8.10.1. Overloading Operators in Value Classes8.10.2. Overloading the Increment and Decrement Operators8.10.3. Overloading Operators in Reference Classes8.10.4. Implementing the Assignment Operator for Reference Types8.11. SUMMARY
9. Class Inheritance and Virtual Functions
9.1. OBJECT-ORIENTED PROGRAMMING BASICS9.2. INHERITANCE IN CLASSES9.2.1. What Is a Base Class?9.2.2. Deriving Classes from a Base Class9.3. ACCESS CONTROL UNDER INHERITANCE9.3.1. Constructor Operation in a Derived Class9.3.2. Declaring Protected Class Members9.3.3. The Access Level of Inherited Class Members9.4. THE COPY CONSTRUCTOR IN A DERIVED CLASS9.5. CLASS MEMBERS AS FRIENDS9.5.1. Friend Classes9.5.2. Limitations on Class Friendship9.6. VIRTUAL FUNCTIONS9.6.1. What Is a Virtual Function?9.6.2. Using Pointers to Class Objects9.6.3. Using References with Virtual Functions9.6.3.1. Incomplete Class Definitions9.6.4. Pure Virtual Functions9.6.5. Abstract Classes9.6.6. Indirect Base Classes9.6.7. Virtual Destructors9.7. CASTING BETWEEN CLASS TYPES9.8. NESTED CLASSES9.9. C++/CLI PROGRAMMING9.9.1. Boxing and Unboxing9.9.2. Inheritance in C++/CLI Classes9.9.3. Interface Classes9.9.4. Defining Interface Classes9.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. Unbound Delegates9.9.7.4. Creating Events9.9.8. Destructors and Finalizers in Reference Classes9.9.9. Generic Classes9.9.9.1. Generic Interface Classes9.9.9.2. Generic Collection Classes9.9.9.3. List<T> — A Generic List9.9.9.4. LinkedList<T> — A Generic Doubly Linked List9.9.9.5. Dictionary<TKey, TValue> — A Generic Dictionary Storing Key/Value Pairs9.10. SUMMARY
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 Objects in the STL10.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.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.6. Sorting Vector Elements10.3.7. Storing Pointers in a Vector10.3.8. Double-Ended Queue Containers10.3.9. Using List Containers10.3.9.1. Adding Elements to a List10.3.9.2. Accessing Elements in a List10.3.9.3. Other Operations on Lists10.3.10. Using Other Sequence Containers10.3.10.1. Queue Containers10.3.10.2. Priority Queue Containers10.3.10.3. Stack Containers10.3.10.4. The array Container10.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.2. Using a Multimap Container10.5. MORE ON ITERATORS10.5.1. Using Input Stream Iterators10.5.2. Using Inserter Iterators10.5.3. Using Output Stream Iterators10.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. LAMBDA EXPRESSIONS10.8.1. The Capture Clause10.8.2. Capturing Specific Variables10.8.3. Templates and Lambda Expressions10.8.4. Wrapping a Lambda Expression10.9. THE STL FOR C++/CLI PROGRAMS10.9.1. STL/CLR Containers10.9.2. Using Sequence Containers10.9.3. Using Associative Containers10.10. LAMBDA EXPRESSIONS IN C++/CLI10.11. SUMMARY
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.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 for Checking the Free Store11.6.2. Controlling Free Store Debug Operations11.6.3. Free Store Debugging Output11.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.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.5. USING WINDOWS FORMS12.6. SUMMARY
13. Programming for Multiple Cores
13.1. PARALLEL PROCESSING BASICS13.2. INTRODUCING THE PARALLEL PATTERNS LIBRARY13.3. ALGORITHMS FOR PARALLEL PROCESSING13.3.1. Using the parallel_for Algorithm13.3.2. Using the parallel_for_each Algorithm13.3.3. Using the parallel_invoke Algorithm13.4. A REAL PARALLEL PROBLEM13.5. CRITICAL SECTIONS13.5.1. Using critical_section Objects13.5.2. Locking and Unlocking a Section of Code13.6. THE COMBINABLE CLASS TEMPLATE13.7. TASKS AND TASK GROUPS13.8. SUMMARY
14. Windows Programming with the Microsoft Foundation Classes
14.1. THE DOCUMENT/VIEW CONCEPT IN MFC14.1.1. What Is a Document?14.1.2. Document Interfaces14.1.3. What Is a View?14.1.4. Linking a Document and Its Views14.1.4.1. Document Templates14.1.4.2. Document Template Classes14.1.5. Your Application and MFC14.2. CREATING MFC APPLICATIONS14.2.1. Creating an SDI Application14.2.2. MFC Application Wizard Output14.2.2.1. Viewing Project Files14.2.2.2. Viewing Classes14.2.2.3. The Class Definitions14.2.2.4. Creating an Executable Module14.2.2.4.1. Precompiled Header Files14.2.2.5. Running the Program14.2.2.6. How the Program Works14.2.2.6.1. The InitInstance() Function14.2.2.6.2. The Run() Function14.2.3. Creating an MDI Application14.2.3.1. Running the Program14.3. SUMMARY
15. Working with Menus and Toolbars
15.1. COMMUNICATING WITH WINDOWS15.1.1. Understanding Message Maps15.1.1.1. Message Handler Definitions15.1.2. Message Categories15.1.3. Handling Messages in Your Program15.1.3.1. How Command Messages Are Processed15.2. EXTENDING THE SKETCHER PROGRAM15.3. ELEMENTS OF A MENU15.3.1. Creating and Editing Menu Resources15.3.1.1. Adding a Menu Item to the Menu Bar15.3.1.2. Adding Items to the Element Menu15.3.1.3. Modifying Existing Menu Items15.3.1.4. Completing the Menu15.4. ADDING HANDLERS FOR MENU MESSAGES15.4.1. Choosing a Class to Handle Menu Messages15.4.2. Creating Menu Message Functions15.4.3. Coding Menu Message Functions15.4.3.1. Adding Members to Store Color and Element Mode15.4.3.2. Initializing the New Class Data Members15.4.3.2.1. Modifying the Class Constructor15.4.3.3. Running the Extended Example15.4.4. Adding Message Handlers to Update the User Interface15.4.4.1. Coding a Command Update Handler15.4.4.2. Exercising the Update Handlers15.5. ADDING TOOLBAR BUTTONS15.5.1. Editing Toolbar Button Properties15.5.2. Exercising the Toolbar Buttons15.5.3. Adding Tooltips15.6. MENUS AND TOOLBARS IN A C++/CLI PROGRAM15.6.1. Understanding Windows Forms15.6.2. Understanding Windows Forms Applications15.6.2.1. Modifying the Properties of a Form15.6.2.2. How the Application Starts15.6.3. Adding a Menu to CLR Sketcher15.6.4. Adding Event Handlers for Menu Items15.6.5. Implementing Event Handlers15.6.6. Setting Menu Item Checks15.6.7. Adding a Toolbar15.7. SUMMARY
16. Drawing in a Window
16.1. BASICS OF DRAWING IN A WINDOW16.1.1. The Window Client Area16.1.2. The Windows Graphical Device Interface16.1.2.1. Working with a Device Context16.1.2.2. Mapping Modes16.2. THE DRAWING MECHANISM IN VISUAL C++16.2.1. The View Class in Your Application16.2.1.1. The OnDraw() Member Function16.2.2. The CDC Class16.2.2.1. Displaying Graphics16.2.2.1.1. Drawing Lines16.2.2.1.2. Drawing Circles16.2.2.2. Drawing in Color16.2.2.2.1. Creating a Pen16.2.2.2.2. Using a Pen16.2.2.2.3. Creating a Brush16.2.2.2.4. Using a Brush16.3. DRAWING GRAPHICS IN PRACTICE16.4. PROGRAMMING FOR THE MOUSE16.4.1. Messages from the Mouse16.4.1.1. WM_LBUTTONDOWN16.4.1.2. WM_MOUSEMOVE16.4.1.3. WM_LBUTTONUP16.4.2. Mouse Message Handlers16.4.3. Drawing Using the Mouse16.4.3.1. Getting the Client Area Redrawn16.4.3.2. Defining Classes for Elements16.4.3.2.1. Storing a Temporary Element in the View16.4.3.3. The CElement Class16.4.3.4. The CLine Class16.4.3.4.1. Implementing the CLine Class16.4.3.4.2. The CLine Class Constructor16.4.3.4.3. Drawing a Line16.4.3.4.4. Creating Bounding Rectangles16.4.3.4.5. Normalized Rectangles16.4.3.5. Calculating the Enclosing Rectangle for a Line16.4.3.6. The CRectangle Class16.4.3.7. The CRectangle Class Constructor16.4.3.7.1. Drawing a Rectangle16.4.3.8. The CCircle Class16.4.3.8.1. Implementing the CCircle Class16.4.3.8.2. The CCircle Class Constructor16.4.3.8.3. Drawing a Circle16.4.3.9. The CCurve Class16.4.3.9.1. Drawing a Curve16.4.3.10. Completing the Mouse Message Handlers16.4.3.10.1. Setting the Drawing Mode16.4.3.10.2. Coding the OnMouseMove() Handler16.4.3.10.3. Creating an Element16.4.3.10.4. Dealing with WM_LBUTTONUP Messages16.5. EXERCISING SKETCHER16.5.1. Running the Example16.5.2. Capturing Mouse Messages16.6. DRAWING WITH THE CLR16.6.1. Drawing on a Form16.6.2. Adding Mouse Event Handlers16.6.3. Defining C++/CLI Element Classes16.6.3.1. Defining a Line16.6.3.1.1. Defining a Color16.6.3.1.2. Drawing Lines16.6.3.1.3. Defining a Pen for Drawing16.6.3.1.4. Standard Pens16.6.3.2. Defining a Rectangle16.6.3.3. Defining a Circle16.6.3.4. Defining a Curve16.6.4. Implementing the MouseMove Event Handler16.6.5. Implementing the MouseUp Event Handler16.6.6. Implementing the Paint Event Handler for the Form16.7. SUMMARY
17. Creating the Document and Improving the View
17.1. CREATING THE SKETCH DOCUMENT17.1.1. Using a list<T> Container for the Sketch17.1.1.1. Implementing the Document Destructor17.1.1.2. Drawing the Document17.1.1.3. Adding an Element to the Document17.1.1.4. Exercising the Document17.2. IMPROVING THE VIEW17.2.1. Updating Multiple Views17.2.2. Scrolling Views17.2.2.1. Logical Coordinates and Client Coordinates17.2.2.2. Dealing with Client Coordinates17.2.3. Using MM_LOENGLISH Mapping Mode17.3. DELETING AND MOVING SHAPES17.4. IMPLEMENTING A CONTEXT MENU17.4.1. Associating a Menu with a Class17.4.1.1. Identifying a Selected Element17.4.2. Exercising the Pop-Ups17.4.3. Highlighting Elements17.4.3.1. Drawing Highlighted Elements17.4.3.2. Exercising the Highlights17.4.4. Servicing the Menu Messages17.4.4.1. Deleting an Element17.4.4.2. Moving an Element17.4.4.3. Modifying the WM_MOUSEMOVE Handler17.4.4.4. Getting the Elements to Move Themselves17.4.4.5. Dropping the Element17.4.4.6. Exercising the Application17.5. DEALING WITH MASKED ELEMENTS17.6. EXTENDING CLR SKETCHER17.6.1. Coordinate System Transformations17.6.2. Defining a Sketch Class17.6.3. Drawing the Sketch in the Paint Event Handler17.6.4. Implementing Element Highlighting17.6.4.1. Finding the Element to Highlight17.6.4.2. Highlighting the Element17.6.5. Adjusting the Bounding Rectangle for an Element17.6.6. Creating Context Menus17.6.6.1. Implementing the Element Delete Operation17.6.6.2. Implementing the "Send to Back" Operation17.6.6.3. Implementing the Element Move Operation17.6.6.4. Moving an Element17.7. SUMMARY
18. Working with Dialogs and Controls
18.1. UNDERSTANDING DIALOGS18.2. UNDERSTANDING CONTROLS18.3. CREATING A DIALOG RESOURCE18.3.1. Adding Controls to a Dialog Box18.3.2. Testing the Dialog18.4. PROGRAMMING FOR A DIALOG18.4.1. Adding a Dialog Class18.4.2. Modal and Modeless Dialogs18.4.3. Displaying a Dialog18.4.3.1. Code to Display the Dialog18.4.3.2. Code to Close the Dialog18.5. SUPPORTING THE DIALOG CONTROLS18.5.1. Initializing the Controls18.5.2. Handling Radio Button Messages18.6. COMPLETING DIALOG OPERATIONS18.6.1. Adding Pen Widths to the Document18.6.2. Adding Pen Widths to the Elements18.6.3. Creating Elements in the View18.6.4. Exercising the Dialog18.7. USING A SPIN BUTTON CONTROL18.7.1. Adding the Scale Menu Item and Toolbar Button18.7.2. Creating the Spin Button18.7.2.1. The Controls' Tab Sequence18.7.3. Generating the Scale Dialog Class18.7.3.1. Dialog Data Exchange and Validation18.7.3.2. Initializing the Dialog18.7.4. Displaying the Spin Button18.8. USING THE SCALE FACTOR18.8.1. Scalable Mapping Modes18.8.2. Setting the Document Size18.8.3. Setting the Mapping Mode18.8.4. Implementing Scrolling with Scaling18.8.4.1. Setting Up the Scrollbars18.9. USING THE CTASKDIALOG CLASS18.9.1. Displaying a Task Dialog18.9.2. Creating CTaskDialog Objects18.9.2.1. Adding Radio Buttons18.9.2.2. Getting Output from Radio Buttons18.10. WORKING WITH STATUS BARS18.10.1. Adding a Status Bar to a Frame18.10.1.1. Creating Status Bar Panes18.10.1.2. Updating the Status Bar18.11. USING A LIST BOX18.11.1. Removing the Scale Dialog18.11.2. Creating a List Box Control18.11.2.1. Creating the Dialog Class18.11.2.2. Displaying the Dialog18.12. USING AN EDIT BOX CONTROL18.12.1. Creating an Edit Box Resource18.12.2. Creating the Dialog Class18.12.2.1. The CString Class18.12.3. Adding the Text Menu Item18.12.4. Defining a Text Element18.12.5. Implementing the CText Class18.12.5.1. The CText Constructor18.12.5.2. Creating a Text Element18.12.5.3. Drawing a CText Object18.12.5.4. Moving a CText Object18.13. DIALOGS AND CONTROLS IN CLR SKETCHER18.13.1. Adding a Dialog18.13.1.1. Customizing the Dialog18.13.1.2. Displaying the Dialog18.13.1.3. Creating Elements with a Pen Width18.13.1.4. Using a Combo Box Control18.13.2. Creating Text Elements18.13.2.1. Drawing Text18.13.2.2. Creating Fonts18.13.2.3. Creating Brushes18.13.2.4. Choosing a Font18.13.2.5. Defining the Text Element Class18.13.2.6. Creating the Text Dialog18.13.2.6.1. Using a Text Box18.13.2.6.2. Displaying the Dialog and Creating a Text Element18.14. SUMMARY
19. Storing and Printing Documents
19.1. UNDERSTANDING SERIALIZATION19.2. SERIALIZING A DOCUMENT19.2.1. Serialization in the Document Class Definition19.2.2. Serialization in the Document Class Implementation19.2.2.1. The Serialize() Function19.2.2.2. The CArchive Class19.2.3. Functionality of CObject-Based Classes19.2.3.1. The Macros Adding Serialization to a Class19.2.4. How Serialization Works19.2.5. How to Implement Serialization for a Class19.3. APPLYING SERIALIZATION19.3.1. Recording Document Changes19.3.2. Serializing the Document19.3.3. Serializing the Element Classes19.3.3.1. The Serialize() Functions for the Shape Classes19.4. EXERCISING SERIALIZATION19.5. PRINTING A DOCUMENT19.5.1. The Printing Process19.5.1.1. The CPrintInfo Class19.6. IMPLEMENTING MULTIPAGE PRINTING19.6.1. Getting the Overall Document Size19.6.2. Storing Print Data19.6.3. Preparing to Print19.6.4. Cleaning Up after Printing19.6.5. Preparing the Device Context19.6.6. Printing the Document19.6.7. Getting a Printout of the Document19.7. SERIALIZATION AND PRINTING IN CLR SKETCHER19.7.1. Understanding Binary Serialization19.7.1.1. Dealing with Fields That Are Not Serializable19.7.1.2. Serializing an Object19.7.2. Serializing a Sketch19.7.2.1. Making the Sketch Class Serializable19.7.2.2. Dealing with Pen and Brush Objects19.7.2.3. Making the Curve Class Serializable19.7.2.4. Implementing File Operations for a Sketch19.7.2.4.1. Creating Dialogs for File Operations19.7.2.4.2. Recording the Saved State of a Sketch19.7.2.4.3. Saving a Sketch19.7.2.4.4. Retrieving a Sketch from a File19.7.2.4.5. Implementing the File New Operation19.7.2.4.6. Dealing with Closing the Form19.7.2.4.7. Supporting the Toolbar Buttons19.7.3. Printing a Sketch19.7.3.1. Using the PrintDocument Component19.7.3.2. Implementing the Print Operation19.8. SUMMARY
20. Writing Your Own DLLs
20.1. UNDERSTANDING DLLS20.1.1. How DLLs Work20.1.1.1. Runtime Dynamic Linking20.1.2. Contents of a DLL20.1.2.1. The DLL Interface20.1.2.2. The DllMain() Function20.1.3. DLL Varieties20.1.3.1. MFC Extension DLL20.1.3.2. Regular DLL — Statically Linked to MFC20.1.3.3. Regular DLL — Dynamically Linked to MFC20.2. DECIDING WHAT TO PUT IN A DLL20.3. WRITING DLLS20.3.1. Writing and Using an Extension DLL20.3.1.1. Understanding DllMain()20.3.1.2. Adding Classes to the Extension DLL20.3.1.3. Exporting Classes from the Extension DLL20.3.1.4. Building a DLL20.3.1.5. Importing Classes from a DLL20.3.1.6. Using the Extension DLL in Sketcher20.3.1.7. Files Required to Use a DLL20.4. SUMMARY

Overview

The leading author of programming tutorials for beginners introduces you to Visual C++ 2010

Ivor Horton is the preeminent author of introductory programming language tutorials; previous editions of his Beginning Visual C++ have sold nearly 100,000 copies. This book is a comprehensive introduction to both the Standard C++ language and to Visual C++ 2010; no previous programming experience is required.

All aspects of the 2010 release are covered, including changes to the language and the C++ standard.

Microsoft Visual C++ is one of the most popular C++ development environments and compilers, used by hundreds of thousands of developers

Ivor Horton's approach to programming tutorials has achieved a huge following; this book gives beginning programmers a comprehensive introduction to both Standard C++ and Visual C++ 2010

Covers all the language changes in Visual C++ 2010, library additions, new MFC features, changes in the Visual Studio development environment, and more

Also includes a brief introduction to programming for multicore processors in native C++ and C++/CLR processors

Nearly 100,000 copies of this book have been sold in previous editions

Beginners seeking a complete education in Visual C++ will find everything they need in Ivor Horton's Beginning Visual C++ 2010.

Note: CD-ROM/DVD and other supplementary materials are not included as part of eBook file.

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++® 2005

Publisher Resources

ISBN: 9780470500880Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills