C++ All-in-One For Dummies

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