C++ For Dummies

Title Page
Copyright Page
Contents at a Glance
Table of Contents
Table of Contents Introduction
Introduction
About This Book
Icons Used in This Book
Beyond the Book
Where to Go from Here
Part I: Getting Started with C++ Programming
Chapter 1: Writing Your First C++ Program
Grasping C++ Concepts
Installing Code::Blocks
Creating Your First C++ Program
Executing Your Program
Reviewing the Annotated Program
Calculating Expressions
Chapter 2: Declaring Variables Constantly
Declaring Variables
Declaring Different Types of Variables
Declaring Variable Types
Wide Loads on Char Highway
Are These Calculations Really Logical?
Mixed Mode Expressions
Automatic Declarations
Chapter 3: Performing Mathematical Operations
Performing Simple Binary Arithmetic
Decomposing Expressions
Determining the Order of Operations
Performing Unary Operations
Using Assignment Operators
Chapter 4: Performing Logical Operations
Why Mess with Logical Operations?
Using the Simple Logical Operators
Expressing Binary Numbers
Performing Bitwise Logical Operations
Chapter 5: Controlling Program Flow
Controlling Program Flow with the Branch Commands
Executing Loops in a Program
Nesting Control Commands
Switching to a Different Subject?
Part II: Becoming a Functional C++ Programmer
Chapter 6: Creating Functions
Writing and Using a Function
Understanding the Details of Functions
Overloading Function Names
Defining Function Prototypes
Defaulting Arguments
Passing by Value and Passing by Reference
Variable Storage Types
Chapter 7: Storing Sequences in Arrays
Arraying the Arguments for Arrays
Using Arrays of Characters
Manipulating Strings with Character
Adding Some Library Functions
Making Room for Wide Strings
Chapter 8: Taking a First Look at C++ Pointers
Variable Size
What’s in an Address?
Address Operators
Using Pointer Variables
Passing Pointers to Functions
Constant const Irritation
Making Use of a Block of Memory Called the Heap
Chapter 9: Taking a Second Look at C++ Pointers
Defining Operations on Pointer Variables
When Is a Pointer Not?
Declaring and Using Arrays of Pointers
Chapter 10: The C++ Preprocessor
What Is a Preprocessor?
Including Files
#Defining Things
Including Things #if I Say So
Intrinsically Defined Objects
Typedef
Part III: Introduction to Classes
Chapter 11: Examining Object-Oriented Programming
Abstracting Microwave Ovens
Classifying Microwave Ovens
Why Classify?
Chapter 12: Adding Class to C++
Introducing the Class
The Format of a Class
Accessing the Members of a Class
Activating Our Objects
Adding a Member Function
Calling a Member Function
Scope Resolution (And I Don’t Mean How Well Your Telescope Works)
Defining a Member Function in the Class
Keeping a Member Function after Class
Overloading Member Functions
Chapter 13: Point and Stare at Objects
Declaring Arrays of Objects
Declaring Pointers to Objects
Passing Objects to Functions
Why Bother with Pointers or References?
Returning to the Heap
Linking Up with Linked Lists
Ray of Hope: A List of Containers Linked to the C++ Library
Chapter 14: Protecting Members: Do Not Disturb
Protecting Members
Making an Argument for Using Protected Members
Giving Non-member Functions Access to Protected Members
Chapter 15: “Why Do You Build Me Up, Just to Tear Me Down, Baby?”
Creating Objects
Using Constructors
Dissecting a Destructor
Chapter 16: Making Constructive Arguments
Outfitting Constructors with Arguments
Placing Too Many Demands on the Carpenter: Overloading the Constructor
Defaulting Default Constructors
Constructing Class Members
Reconstructing the Order of Construction
Constructing Arrays
Constructors as a Form of Conversion
Chapter 17: The Copy/Move Constructor
Copying an Object
The Automatic Copy Constructor
Creating Shallow Copies versus Deep Copies
It’s a Long Way to Temporaries
Chapter 18: Static Members: Can Fabric Softener Help?
Defining a Static Member
Declaring Static Member Functions
What Is this About Anyway?
Part IV: Inheritance
Chapter 19: Inheriting a Class
Do I Need My Inheritance?
How Does a Class Inherit?
Having a HAS_A Relationship
Chapter 20: Examining Virtual Member Functions: Are They for Real?
Why You Need Polymorphism
How Polymorphism Works
When Is a Virtual Function Not?
Considering Virtual Considerations
Chapter 21: Factoring Classes
Factoring
Implementing Abstract Classes
Part V: Security
Chapter 22: A New Assignment Operator, Should You Decide to Accept It
Comparing Operators with Functions.
Inserting a New Operator.
Creating Shallow Copies Is a Deep Problem.
Overloading the Assignment Operator.
Overloading the Subscript Operator.
The Move Constructor and Move Operator.
Chapter 23: Using Stream I/O
How Stream I/O Works.
Stream Input/Output.
Other Methods of the Stream Classes.
Using the stringstream Subclasses.
Manipulating Manipulators.
Chapter 24: Handling Errors — Exceptions
Justifying a New Error Mechanism?.
Examining the Exception Mechanism.
What Kinds of Things Can I Throw?.
Just Passing Through.
Chapter 25: Inheriting Multiple Inheritance
Describing the Multiple Inheritance Mechanism.
Straightening Out Inheritance Ambiguities.
Adding Virtual Inheritance.
Constructing the Objects of Multiple Inheritance.
Voicing a Contrary Opinion.
Chapter 26: Tempting C++ Templates
Generalizing a Function into a Template.
Class Templates.
Tips for Using Templates.
External Template Instantiations.
Implementing an Initializer List.
Chapter 27: Standardizing on the Standard Template Library
The string Container.
Iterating through Lists.
Chapter 28: Writing Hacker-Proof Code
Understanding the Hacker’s Motives.
Understanding Code Injection.
Overflowing Buffers for Fun and Profit.
Part VI: The Part of Tens
Chapter 29: Ten Ways to Avoid Adding Bugs to Your Program
Enable All Warnings and Error Messages
Adopt a Clear and Consistent Coding Style
Limit the Visibility
Comment Your Code While You Write It
Single-Step Every Path at Least Once
Avoid Overloading Operators
Manage the Heap Systematically
Use Exceptions to Handle Errors
Declare Destructors Virtual
Avoid Multiple Inheritance
Chapter 30: Ten Ways to Protect Your Programs from Hackers
Don’t Make Assumptions about User Input
Handle Failures Gracefully
Maintain a Program Log
Follow a Good Development Process
Implement Good Version Control
Authenticate Users Securely
Manage Remote Sessions
Obfuscate Your Code
Sign Your Code With a Digital Certificate
Use Secure Encryption Wherever Necessary
Index
About the Author