Ivor Horton's Beginning Visual C++ 2012

Name: Ivor Horton's Beginning Visual C++ 2012
Brand: Wrox
Price: 38.99 EUR
Availability: OnlineOnly

Ivor Horton(Autor*in)

Wrox (Verlag)

Erschienen am 13. September 2012

942 Seiten

E-Book

ePUB mit Adobe-DRM

Systemvoraussetzungen

978-1-118-41703-4 (ISBN)

38,99 €inkl. 7% MwSt.

Systemvoraussetzungen

für ePUB mit Adobe-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Weitere Details

Weitere Ausgaben

Person

Inhalt

Intro
Ivor Horton's Beginning: Visual C++® 2012
Copyright
About the Author
About the Technical Editor
Credits
Acknowledgments
Contents
Introduction
Who this Book is for
What this Book Covers
How this Book is Structured
What you need to use this Book
Conventions
Source Code
Exercises
Errata
P2P.Wrox.Com
Chapter 1: Programming with Visual C++
Learning with Visual C++
Writing C++ Applications
Learning Desktop Applications Programming
Learning C++
Console Applications
Windows Programming Concepts
What Is the Integrated Development Environment?
The Editor
The Compiler
The Linker
The Libraries
Using the IDE
Toolbar Options
Dockable Toolbars
Documentation
Projects and Solutions
Defining a Project
Debug and Release Versions of Your Program
Executing the Program
Dealing with Errors
Setting Options in Visual C++
Creating and Executing Windows Applications
Creating an MFC Application
Building and Executing the MFC Application
Summary
Chapter 2: Data, Variables, and Calculations
The Structure of a C++ Program
Program Comments
The # include Directive - Header Files
Namespaces and the Using Declaration
The main() Function
Program Statements
Whitespace
Statement Blocks
Automatically Generated Console Programs
Precompiled Header Files
Main Function Names
Defining Variables
Naming Variables
Keywords in C++
Declaring Variables
Initial Values for Variables
Fundamental Data Types
Integer Variables
Character Data Types
Integer Type Modifiers
The Boolean Type
Floating-Point Types
Fundamental Types in C++
Literals
Defining Synonyms for Data Types
Basic Input/Output Operations
Input from the Keyboard
Output to the Command Line
Formatting the Output
Escape Sequences
Calculating in C++
The Assignment Statement
Arithmetic Operations
The const Modifier
Constant Expressions
Program Input
Calculating the Result
Displaying the Result
Calculating a Remainder
Modifying a Variable
The Increment and Decrement Operators
The Sequence of Calculation
Operator Precedence
Type Conversion and Casting
Type Conversion in Assignments
Explicit Type Conversion
Old-Style Casts
The auto Keyword
Discovering Types
The Bitwise Operators
The Bitwise AND
The Bitwise OR
The Bitwise Exclusive OR
The Bitwise NOT
The Bitwise Shift Operators
Introducing Lvalues and Rvalues
Understanding Storage Duration and Scope
Automatic Variables
Positioning Variable Declarations
Global Variables
Static Variables
Variables with Specific Sets of Values
Old Enumerations
Type-Safe Enumerations
Namespaces
Declaring a Namespace
Multiple Namespaces
Summary
Chapter 3: Decisions and Loops
Comparing Values
The if Statement
Nested if Statements
The Extended if Statement
Nested if-else Statements
Logical Operators and Expressions
Logical AND
Logical OR
Logical NOT
The Conditional Operator
The switch Statement
Unconditional Branching
Repeating a Block of Statements
What Is a Loop?
Variations on the for Loop
Using the continue Statement
Floating-Point Loop Counters
The while Loop
The do-while Loop
The Range-Based for Loop
Nested Loops
Summary
Chapter 4: Arrays, Strings, and Pointers
Handling Multiple Data Values of the Same Type
Arrays
Declaring Arrays
Initializing Arrays
Using the Range-Based for Loop
Character Arrays and String Handling
String Input
Using the Range-Based for Loop with Strings
Multidimensional Arrays
Initializing Multidimensional Arrays
Indirect Data Access
What Is a Pointer?
Declaring Pointers
The Address-Of Operator
Using Pointers
The Indirection Operator
Why Use Pointers?
Initializing Pointers
Pointers to char
The sizeof Operator
Constant Pointers and Pointers to Constants
Pointers and Arrays
Pointer Arithmetic
Using Pointers with Multidimensional Arrays
Pointer Notation with Multidimensional Arrays
Dynamic Memory Allocation
The Free Store, Alias the Heap
The new and delete Operators
Allocating Memory Dynamically for Arrays
Dynamic Allocation of Multidimensional Arrays
Using References
What Is a Reference?
Declaring and Initializing Lvalue References
Using References in a Range-Based for Loop
Rvalue References
Library Functions for Strings
Finding the Length of a Null-Terminated String
Joining Null-Terminated Strings
Copying Null-Terminated Strings
Comparing Null-Terminated Strings
Searching Null-Terminated Strings
Summary
Chapter 5: Introducing Structure into your Programs
Understanding Functions
Why Do You Need Functions?
Structure of a Function
The Function Header
The Function Body
The return Statement
Alternative Function Syntax
Using a Function
Function Prototypes
Passing Arguments to a Function
The Pass-by-Value Mechanism
Pointers as Arguments to a Function
Passing Arrays to a Function
Passing Multidimensional Arrays to a Function
References as Arguments to a Function
Use of the const Modifier
Rvalue Reference Parameters
Arguments to main( )
Accepting a Variable Number of Function Arguments
Returning Values from a Function
Returning a Pointer
A Cast-Iron Rule for Returning Addresses
Returning a Reference
A Teflon-Coated Rule: Returning References
Static Variables in a Function
Recursive Function Calls
Using Recursion
Summary
Chapter 6: More about Program Structure
Pointers to Functions
Declaring Pointers to Functions
A Pointer to a Function as an Argument
Arrays of Pointers to Functions
Initializing Function Parameters
Exceptions
Throwing Exceptions
Catching Exceptions
Rethrowing Exceptions
Exception Handling in the MFC
Handling Memory Allocation Errors
Function Overloading
What Is Function Overloading?
Reference Types and Overload Selection
When to Overload Functions
Function Templates
Using a Function Template
Using the decltype Operator
An Example Using Functions
Implementing a Calculator
Analyzing the Problem
Eliminating Blanks from a String
How the Function Functions
Evaluating an Expression
How the Function Functions
Getting the Value of a Term
How the Function Functions
Analyzing a Number
How the Function Functions
Putting the Program Together
How the Function Functions
Extending the Program
How the Function Functions
Extracting a Substring
How the Function Functions
Running the Modified Program
Summary
Chapter 7: Defining Your Own Data Types
The struct in C++
What Is a struct?
Defining a struct
Initializing a struct
Accessing the Members of a struct
IntelliSense Assistance with Structures
The struct RECT
Using Pointers with a struct
Accessing Structure Members through a Pointer
The Indirect Member Selection Operator
Types, Objects, Classes, and Instances
First Class
Operations on Classes
Terminology
Understanding Classes
Defining a Class
Access Control in a Class
Declaring Objects of a Class
Accessing the Data Members of a Class
Member Functions of a Class
Positioning a Member Function Definition
Inline Functions
Class Constructors
What Is a Constructor?
The Default Constructor
Default Parameter Values
Using an Initialization List in a Constructor
Making a Constructor Explicit
Private Members of a Class
Accessing private Class Members
The friend Functions of a Class
Placing friend Function Definitions Inside the Class
The Default Copy Constructor
The Pointer this
const Objects
const Member Functions of a Class
Member Function Definitions Outside the Class
Arrays of Objects
Static Members of a Class
Static Data Members
Static Function Members of a Class
Pointers and References to Objects
Pointers to Objects
References to Class Objects
Implementing a Copy Constructor
Summary
Chapter 8: More on Classes
Class Destructors
What Is a Destructor?
The Default Destructor
Destructors and Dynamic Memory Allocation
Implementing a Copy Constructor
Sharing Memory Between Variables
Defining Unions
Anonymous Unions
Unions in Classes and Structures
Operator Overloading
Implementing an Overloaded Operator
Implementing Full Support for Comparison Operators
Overloading the Assignment Operator
Fixing the Problem
Overloading the Addition Operator
Overloading the Increment and Decrement Operators
Overloading the Function Call Operator
The Object Copying Problem
Avoiding Unnecessary Copy Operations
Applying Rvalue Reference Parameters
Named Objects are Lvalues
Default Class Members
Class Templates
Defining a Class Template
Template Member Functions
Creating Objects from a Class Template
Class Templates with Multiple Parameters
Templates for Function Objects
Perfect Forwarding
Using Classes
The Idea of a Class Interface
Defining the Problem
Implementing the CBox Class
Comparing CBox Objects
Combining CBox Objects
Analyzing CBox Objects
Organizing Your Program Code
Naming Program Files
Library Classes for Strings
Creating String Objects
Concatenating Strings
Accessing and Modifying Strings
Comparing Strings
Searching Strings
Summary
Chapter 9: Class Inheritance and Virtual Functions
Object-Oriented Programming Basics
Inheritance in Classes
What Is a Base Class?
Deriving Classes from a Base Class
Access Control Under Inheritance
Constructor Operation in a Derived Class
Declaring Protected Class Members
The Access Level of Inherited Class Members
The Copy Constructor in a Derived Class
Preventing Class Derivation
Class Members as Friends
Friend Classes
Limitations on Class Friendship
Virtual Functions
What Is a Virtual Function?
Ensuring Correct Virtual Function Operation
Preventing Function Overriding
Using Pointers to Class Objects
Using References with Virtual Functions
Incomplete Class Declaration
Pure Virtual Functions
Abstract Classes
Indirect Base Classes
Virtual Destructors
Casting Between Class Types
Nested Classes
Summary
Chapter 10: The Standard Template Library
What Is the Standard Template Library?
Containers
Allocators
Comparators
Container Adapters
Iterators
Iterator Categories
SCARY Iterators
std::begin( ) and std::end( ) Functions
Smart Pointers
Using unique_ptr Objects
Using shared_ptr Objects
Accessing the Raw Pointer in a Smart Pointer
Casting SmartPointers
Algorithms
Function Objects in the STL
Function Adapters
The Range of STL Containers
Sequence Containers
Creating Vector Containers
The Capacity and Size of a Vector Container
Accessing the Elements in a Vector
Inserting and Deleting Elements in a Vector
Insert Operations
Emplace Operations
Erase Operations
Swap and Assign Operations
Storing Class Objects in a Vector
Sorting Vector Elements
Storing Pointers in a Vector
Array Containers
Double-Ended Queue Containers
Using List Containers
Adding Elements to a List
Accessing Elements in a List
Sorting List Elements
Other Operations on Lists
Using forward_list Containers
Using Other Sequence Containers
Queue Containers
Priority Queue Containers
Stack Containers
The tuple Class Template
Associative Containers
Using Map Containers
Storing Objects
Accessing Objects
Other Map Operations
Using a Multimap Container
More on Iterators
Using Input Stream Iterators
Using Inserter Iterators
Using Output Stream Iterators
More on Function Objects
More on Algorithms
Type Traits and Static Assertions
Lambda Expressions
The Capture Clause
Capturing Specific Variables
Templates and Lambda Expressions
Naming a Lambda Expression
Summary
Chapter 11: Windows Programming Concepts
Windows Programming Basics
Elements of a Window
Windows Programs and the Operating System
Event-Driven Programs
Windows Messages
The Windows API
Windows Data Types
Notation in Windows Programs
The Structure of a Windows Program
The WinMain( ) Function
Specifying a Program Window
Creating a Program Window
Initializing the Program Window
Dealing with Windows Messages
A Complete WinMain( ) Function
How It Works
Processing Windows Messages
The WindowProc( ) Function
Decoding a Windows Message
Ending the Program
A Complete WindowProc( ) Function
How It Works
The Microsoft Foundation Classes
MFC Notation
How an MFC Program Is Structured
Summary
Chapter 12: Windows Programming with the Microsoft Foundation Classes (MFC)
The MFC Document/View Concept
What Is a Document?
Document Interfaces
What Is a View?
Linking a Document and Its Views
Document Templates
Document Template Classes
Your Application and MFC
Creating MFC Applications
Creating an SDI Application
MFC Application Wizard Output
Viewing Project Files
Viewing Classes
The Class Definitions
Creating an Executable Module
Running the Program
How the Program Works
Creating an MDI Application
Running the Program
Summary
Chapter 13: Working With Menus and Toolbars
Communicating with Windows
Understanding Message Maps
Message Handler Definitions
Message Categories
Handling Messages in Your Program
How Command Messages Are Processed
Extending the Sketcher Program
Elements of a Menu
Creating and Editing Menu Resources
Adding a Menu Item to the Menu Bar
Adding Items to the Element Menu
Modifying Existing Menu Items
Completing the Menu
Adding Menu Message Handlers
Choosing a Class to Handle Menu Messages
Creating Menu Message Handlers
Implementing Menu Message Handlers
Adding Members to Store Color and Element Mode
Defining Element and Color Types
Initializing the Color and Element Type Members
Implementing Menu Command Message Handlers
Running the Extended Example
Adding Menu Update Message Handlers
Coding a Command Update Handler
Exercising the Update Handlers
Adding Toolbar Buttons
Editing Toolbar Button Properties
Exercising the Toolbar Buttons
Adding Tooltips
Summary
Chapter 14: Drawing in a Window
Basics of Drawing in a Window
The Window Client Area
The Windows Graphical Device Interface
Working with a Device Context
Mapping Modes
The MFC Drawing Mechanism
The View Class in Your Application
The OnDraw( ) Member Function
The CDC Class
Displaying Graphics
Drawing in Color
Drawing Graphics in Practice
Programming for the Mouse
Messages from the Mouse
WM_LBUTTONDOWN
WM_MOUSEMOVE
WM_LBUTTONUP
Mouse Message Handlers
Drawing Using the Mouse
Getting the Client Area Redrawn
Defining Element Classes
The CElement Class
The CLine Class
The CRectangle Class
The CCircle Class
The CCurve Class
Completing the Mouse Message Handlers
Drawing a Sketch
Running the Example
Capturing Mouse Messages
Summary
Chapter 15: Improving the View
Sketcher Limitations
Improving the View
Updating Multiple Views
Scrolling Views
Logical Coordinates and Client Coordinates
Dealing with Client Coordinates
Using MM_LOENGLISH Mapping Mode
Deleting and Moving Elements
Implementing a Context Menu
Associating a Menu with a Class
Checking Context Menu Items
Identifying an Element under the Cursor
Exercising the Context Menus
Highlighting Elements
Drawing Highlighted Elements
Exercising the Highlights
Implementing Move and Delete
Deleting an Element
Moving an Element
Updating Other Views
Getting the Elements to Move Themselves
Dropping the Element
Exercising the Application
Dealing with Masked Elements
Summary
Chapter 16: Working with Dialogs and Controls
Understanding Dialogs
Understanding Controls
Creating a Dialog Resource
Adding Controls to a Dialog
Testing the Dialog
Programming for a Dialog
Adding a Dialog Class
Modal and Modeless Dialogs
Displaying a Dialog
Displaying the Dialog
Code to Close the Dialog
Supporting the Dialog Controls
Initializing Dialog Controls
Handling Radio Button Messages
Completing Dialog Operations
Adding Pen Widths to the Document
Adding Pen Widths to the Elements
Creating Elements in the View
Exercising the Dialog
Using a Spin Button Control
Adding a Scale Menu Item and Toolbar Button
Creating the Spin Button
The Controls' Tab Sequence
Generating the Scale Dialog Class
Dialog Data Exchange and Validation
Initializing the Dialog
Displaying the Spin Button
Using the Scale Factor
Scalable Mapping Modes
Setting the Document Size
Setting the Mapping Mode
Implementing Scrolling with Scaling
Setting Up the Scrollbars
Working with Status Bars
Adding a Status Bar to a Frame
Creating Status Bar Panes
Updating the Status Bar
The CString Class
Using an Edit Box Control
Creating an Edit Box Resource
Creating the Dialog Class
Adding the Text Menu Item
Defining a Text Element
Implementing the CText Class
The CText Constructor
Creating a Text Element
Drawing a CText Object
Moving a CText Object
Summary
Chapter 17: Storing and Printing Documents
Understanding Serialization
Serializing a Document
Serialization in the Document Class Definition
Serialization in the Document Class Implementation
The Serialize( ) Function
The CArchive Class
Functionality of CObject-Based Classes
The Macros that Add Serialization to a Class
How Serialization Works
How to Implement Serialization for a Class
Applying Serialization
Recording Document Changes
Serializing the Document
Serializing the Element Classes
The Serialize( ) Functions for the Element Classes
Exercising Serialization
Printing a Document
The Printing Process
The CPrintInfo Class
Implementing Multipage Printing
Getting the Overall Document Size
Storing Print Data
Preparing to Print
Cleaning Up after Printing
Preparing the Device Context
Printing the Document
Getting a Printout of the Document
Summary
Chapter 18: Programming Windows 8 Apps
Understanding Windows 8 Apps
Developing Windows 8 Apps
Windows Runtime Concepts
WinRT Namespaces
WinRT Objects
C++ Component Extensions (C++/CX)
C++/CX Namespaces
Defining WinRT Class Types
Variables of Ref Class Types
Accessing Members of a Ref Class Object
Event Handler Functions
Casting Ref Class References
The eXtensible Application Markup Language (XAML)
XAML Elements
UI Elements in XAML
Attached Properties
Parents and Children
Control Elements
Layout Elements
Handling Events for UI Elements
Creating a Windows 8 App
Application Files
Defining the User Interface
Creating the Title
Adding Game Controls
Creating a Grid to Contain the Cards
Defining a Card
Creating a Card
Adding Event Handling
Creating All the Cards
Implementing Game Operations
Defining the Card Class
Adding Data Members to the MainPage Class
Adding Function Members
Initialize the MainPage Object
Initializing the Card Pack
Setting Up the Child Elements of cardGrid
Initializing the Game
Shuffling the Cards
Highlighting the UI Cards
Handling Card Back Events
Handling Shape Events
Recognizing a Win
Handling Game Control Button Events
Scaling UI Elements
Transitions
Application Startup Transitions
Storyboard Animations
Summary
Index
Advertisement

Systemvoraussetzungen

Als PDF speichern Als Link merken