Beginning Programming with C++ For Dummies

Title Page
Copyright Page
Table of Contents
Introduction
About This Book
Foolish Assumptions
How This Book Is Organized
Part I: Getting Started with C++ Programming
Part II: Writing a Program: Decisions, Decisions
Part III: Becoming a Procedural Programmer
Part IV: Data Structures
Part V: Object-Oriented Programming
Part VI: Advanced Strokes
Part VII: The Part of Tens
Icons Used in This Book
Beyond the Book
Where to Go from Here
Part I: Getting Started with C++ Programming
Chapter 1: What Is a Program?
How Does My Son Differ from a Computer?
Programming a “Human Computer”
Creating the algorithm
Setting the tire-changing language
Constructing the program
Computer processors
Computer Languages
High-level languages
The C++ language
Chapter 2: Installing Code::Blocks
Reviewing the Compilation Process
Installing Code::Blocks
Windows installation
Ubuntu Linux installation
Mac OS installation
Setting up Code::Blocks
Testing the Code::Blocks Installation
Creating the project
Testing your default project
Chapter 3: Writing Your First Program
Creating a New Project
Filename extensions
Entering Your Program
Building the Program
Finding What Could Go Wrong
Misspelled commands
Missing semicolon
Using the Online Material
Running the Program
How the Program Works
The template
The Conversion program
Part II: Writing a Program: Decisions, Decisions
Chapter 4: Integer Expressions
Declaring Variables
Variable names
Assigning a value to a variable
Initializing a variable at declaration
Integer Constants
Expressions
Binary operators
Unraveling compound expressions
Unary Operators
The Special Assignment Operators
Chapter 5: Character Expressions
Defining Character Variables
Encoding characters
Example of character encoding
Encoding Strings of Characters
Special Character Constants
Chapter 6: if I Could Make My Own Decisions
The if Statement
Comparison operators
Say “No” to “No braces”
What Else Is There?
Nesting if Statements
Compound Conditional Expressions
Chapter 7: Switching Paths
Controlling Flow with the switch Statement
Control Fell Through: Did I break It?
Implementing an Example Calculator with the switch Statement
Chapter 8: Debugging Your Programs, Part I
Identifying Types of Errors
Avoiding Introducing Errors
Coding with style
Establishing variable naming conventions
Finding the First Error with a Little Help
Finding the Run-Time Error
Formulating test data
Executing the test cases
Seeing what’s going on in your program
Part III: Becoming a Procedural Programmer
Chapter 9: while Running in Circles
Creating a while Loop
Breaking out of the Middle of a Loop
Nested Loops
Chapter 10: Looping for the Fun of It
The for Parts of Every Loop
Looking at an Example
Getting More Done with the Comma Operator
Chapter 11: Functions, I Declare!
Breaking Your Problem Down into Functions
Understanding How Functions Are Useful
Writing and Using a Function
Returning things
Reviewing an example
Passing Arguments to Functions
Function with arguments
Functions with multiple arguments
Exposing main( )
Defining Function Prototype Declarations
Chapter 12: Dividing Programs into Modules
Breaking Programs Apart
Breaking Up Isn’t That Hard to Do
Creating Factorial.cpp
Creating an #include file
Including #include files
Creating main.cpp
Building the result
Using the Standard C++ Library
Variable Scope
Chapter 13: Debugging Your Programs, Part 2
Debugging a Dys-Functional Program
Performing unit level testing
Outfitting a function for testing
Returning to unit test
Part IV: Data Structures
Chapter 14: Other Numerical Variable Types
The Limitations of Integers in C++
Integer round-off
Limited range
A Type That “doubles” as a Real Number
Solving the truncation problem
When an integer is not an integer
Discovering the limits of double
Variable Size — the “long” and “short” of It
How far do numbers range?
Types of Constants
Passing Different Types to Functions
Overloading function names
Mixed-mode overloading
Chapter 15: Arrays
What Is an Array?
Declaring an Array
Indexing into an Array
Looking at an Example
Initializing an Array
Chapter 16: Arrays with Character
The ASCII-Zero Character Array
Declaring and Initializing an ASCIIZ Array
Looking at an Example
Looking at a More Detailed Example
Foiling hackers
Do I Really Have to Do All That Work?
Chapter 17: Pointing the Way to C++ Pointers
What’s a Pointer?
Declaring a Pointer
Passing Arguments to a Function
Passing arguments by value
Passing arguments by reference
Putting it together
Reference argument types
Playing with Heaps of Memory
Do you really need a new keyword?
Don’t forget to clean up after yourself
Looking at an example
Chapter 18: Taking a Second Look at C++ Pointers
Pointers and Arrays
Operations on pointers
Pointer addition versus indexing into an array
Using the pointer increment operator
Why bother with array pointers?
Operations on Different Pointer Types
Constant Nags
Differences Between Pointers and Arrays
My main( ) Arguments
Arrays of pointers
Arrays of arguments
Chapter 19: Programming with Class
Grouping Data
The Class
The Object
Arrays of Objects
Looking at an Example
Chapter 20: Debugging Your Programs, Part 3
A New Approach to Debugging
The solution
Entomology for Dummies
Starting the debugger
Fixing the (first) bug
Finding and fixing the second bug
Part V: Object-Oriented Programming
Chapter 21: What Is Object-Oriented Programming?
Abstraction and Microwave Ovens
Procedural nachos
Object-oriented nachos
Classification and Microwave Ovens
Why Build Objects This Way?
Self-Contained Classes
Chapter 22: Structured Play: Making Classes Do Things
Activating Our Objects
Creating a Member Function
Defining a member function
Naming class members
Calling a member function
Accessing other members from within a member function
Keeping a Member Function after Class
Overloading Member Functions
Chapter 23: Pointers to Objects
Pointers to Objects
Arrow syntax
Calling all member functions
Passing Objects to Functions
Calling a function with an object value
Calling a function with an object pointer
Looking at an example
Allocating Objects off the Heap
Chapter 24: Do Not Disturb: Protected Members
Protecting Members
Why you need protected members
Making members protected
So what?
Who Needs Friends, Anyway?
Chapter 25: Getting Objects Off to a Good Start
The Constructor
Limitations on constructors
Can I see an example?
Constructing data members
Destructors
Looking at an example
Destructing data members
Chapter 26: Making Constructive Arguments
Constructors with Arguments
Looking at an example
Overloading the Constructor
The Default default Constructor
Constructing Data Members
Initializing data members with the default constructor
Initializing data members with a different constructor
Looking at an example
New with C++ 2011
Chapter 27: Coping with the Copy Constructor
Copying an Object
The default copy constructor
Looking at an example
Creating a Copy Constructor
Avoiding Copies
Part VI: Advanced Strokes
Chapter 28: Inheriting a Class
Advantages of Inheritance
Learning the lingo
Implementing Inheritance in C++
Looking at an example
Having a HAS_A Relationship
Chapter 29: Are Virtual Functions for Real?
Overriding Member Functions
Early binding
Ambiguous case
Enter late binding
When Is Virtual Not?
Virtual Considerations
Chapter 30: Overloading Assignment Operators
Overloading an Operator
Overloading the Assignment Operator Is Critical
Looking at an Example
Writing Your Own (or Not)
Chapter 31: Performing Streaming I/O
How Stream I/O Works
Stream Input/Output
Creating an input object
Creating an output object
Open modes
What is binary mode?
Hey, file, what state are you in?
Other Member Functions of the fstream Classes
Reading and writing streams directly
Controlling format
What’s up with endl?
Manipulating Manipulators
Using the stringstream Classes
Chapter 32: I Take Exception!
The Exception Mechanism
Examining the exception mechanism in detail
Special considerations for throwing
Creating a Custom Exception Class
Restrictions on exception classes
Part VII: The Part of Tens
Chapter 33: Ten Ways to Avoid Bugs
Enable All Warnings and Error Messages
Adopt a Clear and Consistent Coding Style
Comment the Code While You Write It
Single-Step Every Path in the Debugger at Least Once
Limit the Visibility
Keep Track of Heap Memory
Zero Out Pointers after Deleting What They Point To
Use Exceptions to Handle Errors
Declare Destructors Virtual
Provide a Copy Constructor and Overloaded Assignment Operator
Chapter 34: Ten Features Not Covered in This Book
The goto Command
The Ternary Operator
Binary Logic
Enumerated Types
Namespaces
Pure Virtual Functions
The string Class
Multiple Inheritance
Templates and the Standard Template Library
Lambda Functions
Index
About the Author
Wiley End User License Agreement