http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-2.xsd
xxxvii, 917 pages : illustrations ; 24 cm.
This indispensable guidebook will teach you the latest techniques to take your Visual C++ coding to an all-new level. Horton introduces you to both Standard C++ and Visual C++ so you can build any component your app require. Learn through plenty of exercises and solutions the C++ language and library changes supported under Visual Studio 2013 IDE-specific changes for code formatting and debugging Changes to the C++ Standard Language for both C++ 11 and the new C++ 14 and more.
Machine generated contents note: ch. 1 Programming With Visual C++ -- Learning with Visual C++ -- Writing C++ Applications -- Learning Desktop Applications Programming -- Learning C++ -- C++ Concepts -- Functions -- Data and Variables -- Classes and Objects -- Templates -- Program Files -- Console Applications -- Windows Programming Concepts -- The Integrated Development Environment -- The Editor -- The Compiler -- The Linker -- The Libraries -- The Standard C++ Library -- Microsoft 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 -- ch. 2 Data, Variables, And Calculations -- The Structure of a C++ Program -- Program Comments.
Contents note continued: 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 -- 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 Type Aliases -- 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.
Contents note continued: 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 -- ch. 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.
Contents note continued: 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 -- ch. 4 Arrays, Strings, And Pointers -- Handling Multiple Data Values of the Same Type -- Arrays -- Declaring Arrays -- Initializing Arrays -- Using the Range-based for Loop -- Multidimensional Arrays -- Initializing Multidimensional Arrays -- Working with C-Style Strings -- String Input -- String Literals -- Using the Range-based for Loop with Strings -- 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.
Contents note continued: 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 -- Creating 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 -- ch. 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.
Contents note continued: 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 Cast-Iron Rule: Returning References -- Static Variables in a Function -- Recursive Function Calls -- Using Recursion -- Summary -- ch. 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.
Contents note continued: 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 -- ch. 7 Defining Your Own Data Types -- The struct in C++ -- What Is a struct? -- Defining a struct -- Initializing a struct.
Contents note continued: Accessing the Members of a struct -- IntelliSense Assistance with Structures -- The RECT Structure -- 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 -- Memberwise Initialization of an Object -- Initializing Class Members -- Member Functions of a Class -- Defining a Member Function Outside a Class -- Inline Functions -- Class Constructors -- What Is a Constructor? -- The Default Constructor -- Default Parameter Values -- Using a Constructor Initialization List -- Making a Constructor Explicit -- Delegating Constructors -- Private Members of a Class -- Accessing private Class Members -- The friend Functions of a Class.
Contents note continued: 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 -- ch. 8 More On Classes -- Class Destructors -- What Is a Destructor? -- The Default Destructor -- Destructors and Dynamic Memory Allocation -- Implementing a Copy Constructor -- 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.
Contents note continued: 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 -- Default Arguments for Template Parameters -- Default Function Template Arguments -- Default Class Template Arguments -- Aliases for Class Templates -- Template Specialization -- 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.
Contents note continued: Summary -- ch. 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 -- Pure Virtual Functions -- Abstract Classes -- Indirect Base Classes -- Virtual Destructors -- Casting Between Class Types -- Defining Conversion Operators -- Explicit Conversion Operators -- Nested Classes -- Summary.
Contents note continued: ch. 10 The Standard Template Library -- What Is the Standard Template Library? -- Containers -- Allocators -- Comparators -- Container Adapters -- Iterators -- Iterator Categories -- SCARY Iterators -- Functions Returning Iterators -- Smart Pointers -- Using unique_ptr Objects -- Using shared_ptr Objects -- Accessing the Raw Pointer in a Smart Pointer -- Casting Smart Pointers -- 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.
Contents note continued: 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 -- ch. 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.
Contents note continued: 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 -- ch. 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.
Contents note continued: Viewing Classes -- The Class Definitions -- Creating an Executable Module -- Running the Program -- How the Program Works -- Creating an MDI Application -- Running the Program -- Summary -- ch. 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.
Contents note continued: 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 -- ch. 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.
Contents note continued: The CRectangle Class -- The CCircle Class -- The CCurve Class -- Completing the Mouse Message Handlers -- Drawing a Sketch -- Running the Example -- Capturing Mouse Messages -- Summary -- ch. 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.
Contents note continued: ch. 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.
Contents note continued: 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 -- ch. 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.
Contents note continued: 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 -- ch. 18 Programming For Windows 8 -- Windows Store Applications -- Developing Windows Store 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 Handlers -- Casting Ref Class References -- The Extensible Application Markup Language (XAML) -- XAML Elements -- UI Elements in XAML.
Contents note continued: Attached Properties -- Parents and Children -- Control Elements -- Layout Elements -- Handling Events for UI Elements -- Creating a Windows Store 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 Member Functions -- 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.