C++ All-in-One For Dummies, 3rd Edition

Title Page
Copyright Page
Contents at a Glance
Table of Contents
Introduction
	No Experience Necessary
	Great for Advanced Folks, Too!
	For All Computers
	Conventions
	Organization
	Icons Galore
	What’s Next?
	Beyond the Book
Book I: Getting Started with C++
	Chapter 1: Configuring Your System
		Obtaining a Copy of C++ 14
		Obtaining Code::Blocks
		Installing Code::Blocks
		Touring the Essential Code::Blocks Features
		Using Other IDEs
	Chapter 2: Creating Your First C++ Application
		Code::Blocks Creating a Project
		Typing the Code
		Starting with Main
		Showing Information
		Let Your Application Run Away
	Chapter 3: Storing Data in C++
		Putting Your Data Places: Variables
		Manipulating Integer Variables
		Characters
		Strings
		Deciding between Conditional Operators
		Telling the Truth with Boolean Variables
		Reading from the Console
	Chapter 4: Directing the Application Flow
		Doing This or Doing That
		Evaluating Conditions in C++
		Including Evaluations in C++ Conditional Statements
		Repeating Actions with Statements That Loop
	Chapter 5: Dividing Your Work with Functions
		Dividing Your Work
		Calling a Function
		Writing Your Own Functions
		Calling All String Functions
		Understanding main()
	Chapter 6: Splitting Up Source Code Files
		Creating Multiple Source Files
		Sharing with Header Files
		Sharing Variables among Source Files
		Using the Mysterious Header Wrappers
	Chapter 7: Referring to Your Data Through Pointers
		Heaping and Stacking the Variables
		Dynamically Allocating with new
		Freeing Pointers
		Passing Pointer Variables to Functions
		Returning Pointer Variables from Functions
		Returning a Pointer as a Nonpointer
		Passing by Reference
		Passing By const Reference
		Remembering the Rules
	Chapter 8: Working with Classes
		Understanding Objects and Classes
		Working with a Class
		Starting and Ending with Constructors and Destructors
		Building Hierarchies of Classes
		Creating and Using Object Aliases
	Chapter 9: Using Advanced C++ Features
		Filling Your Code with Comments
		Converting Types
		Reading from the Console
		Understanding Preprocessor Directives
		Using Constants
		Using Switch Statements
		Supercharging enums with Classes
		Working with Random Numbers
		Storing Data in Arrays
Book II: Understanding Objects and Classes
	Chapter 1: Planning and Building Objects
		Recognizing Objects
		Encapsulating Objects
		Building Hierarchies
		Discovering Classes
	Chapter 2: Describing Your Program with UML
		Moving Up to UML
		Building with UML and the Rational Unified Process
		Moving Forward with UML
	Chapter 3: Structuring Your Classes with UML
		Drawing Classes
		Building Components
		Deploying the Software
	Chapter 4: Demonstrating Behavior with UML
		Drawing Objects
		Casing Out the Use Cases
		Sequence Diagrams
		Collaboration Diagrams
		Activity Diagrams
		State Diagrams
	Chapter 5: Modeling Your Applications with UML
		Using UML Goodies
		Free to Be UML
		C++ and UML
	Chapter 6: Building with Design Patterns
		Introducing a Simple Pattern: the Singleton
		Watching an Instance with an Observer
		Mediating with a Pattern
Book III: Fixing Problems
	Chapter 1: Dealing with Bugs
		It’s Not a Bug. It’s a Feature!
		Make Your Application Features Look Like Features
		Anticipating (Almost) Everything
		Avoiding Mistakes, Plain and Simple
	Chapter 2: Debugging an Application
		Programming with Debuggers
		Debugging with Different Tools
		Debugging a Code::Blocks Application with Command Line Arguments
	Chapter 3: Stopping and Inspecting Your Code
		Setting and Disabling Breakpoints
		Watching, Inspecting, and Changing Variables
	Chapter 4: Traveling About the Stack
		Stacking Your Data
		Debugging with Advanced Features
Book IV: Advanced Programming
	Chapter 1: Working with Arrays, Pointers, and References
		Building Up Arrays
		Pointing with Pointers
		Referring to References
	Chapter 2: Creating Data Structures
		Working with Data
		Structuring Your Data
		Naming Your Space
	Chapter 3: Constructors, Destructors, and Exceptions
		Constructing and Destructing Objects
		Programming the Exceptions to the Rule
	Chapter 4: Advanced Class Usage
		Inherently Inheriting Correctly
		Using Classes and Types within Classes
	Chapter 5: Creating Classes with Templates
		Templatizing a Class
		Parameterizing a Template
		Typedefing a Template
		Deriving Templates
		Templatizing a Function
	Chapter 6: Programming with the Standard Library
		Architecting the Standard Library
		Containing Your Classes
		The Great Container Showdown
		Copying Containers
		Creating and Using Dynamic Arrays
		Working with Unordered Data
	Chapter 7: Working with Lambda Expressions
		Creating More Readable and Concise C++ Code
		Defining the Essential Lambda Expression
		Developing Applications with Lambda Expressions
Book V: Reading and Writing Files
	Chapter 1: Filing Information with the Streams Library
		Seeing a Need for Streams
		Programming with the Streams Library
		Handling Errors When Opening a File
		Flagging the ios Flags
	Chapter 2: Writing with Output Streams
		Inserting with the << Operator
		Formatting Your Output
	Chapter 3: Reading with Input Streams
		Extracting with Operators
		Encountering the End of File
		Reading Various Types
		Reading Formatted Input
	Chapter 4: Building Directories and Contents
		Manipulating Directories
		Getting the Contents of a Directory
		Copying Files
		Moving and Renaming Files and Directories
	Chapter 5: Streaming Your Own Classes
		Streaming a Class for Text Formatting
		Manipulating a Stream
Book VI: Advanced C++
	Chapter 1: Exploring the Standard Library Further
		Considering the Standard Library Categories
		Parsing Strings Using a Hash
		Obtaining Information Using a Random Access Iterator
		Locating Values Using the Find Algorithm
		Using the Random Number Generator
		Performing Comparisons Using min and max
		Working with Temporary Buffers
	Chapter 2: Working with User-Defined Literals (UDLs)
		Understanding the Need for UDLs
		Working with the UDLs Included in the Standard Library
		Creating Your Own UDLs
	Chapter 3: Building Original Templates
		Deciding When to Create a Template
		Defining the Elements of a Good Template
		Creating a Basic Math Template
		Building a Structure Template
		Developing a Class Template
		Considering Template Specialization
		Creating a Template Library
		Using Your Template Library
	Chapter 4: Investigating Boost
		Understanding Boost
		Obtaining and Installing Boost for Code::Blocks
		Creating the Boost Tools
		Using Boost.Build
		Using Regression
		Using Inspect
		Understanding BoostBook
		Using QuickBook
		Using bcp
		Using Wave
		Building Your First Boost Application Using Date Time
	Chapter 5: Boosting up a Step
		Parsing Strings Using RegEx
		Breaking Strings into Tokens Using Tokenizer
		Performing Numeric Conversion
		Creating Improved Loops Using Foreach
		Accessing the Operating System Using Filesystem
Appendix: Automating Your Applications with Makefiles
Index
About the Authors
Wiley End User License Agreement