C++ for Dummies

C++ for Dummies
	Cover
Table of Contents
Introduction
	What's in This Book
	What's on the CD
	What Is C++?
	Conventions Used in This Book
	How This Book Is Organized
	And There's More
	Part I: Introduction to C++ Programming
	Part II: Becoming a Functional C++ Programmer
	Part III: Introduction to Classes
	Part IV: Inheritance
	Part V: Optional Features
	Part VI: The Part of Tens
	Icons Used in This Book
	Where to Go from Here
Part I: Introduction to C++ Programming
	Chapter 1: Writing Your First C++ Program
		Grasping C++ Concepts
			What's a program?
			How do I program?
		Installing Dev-C++
			Setting the options
		Creating Your First C++ Program
			Entering the C++ code
			Building your program
		Executing Your Program
			Dev-C++ is not Windows
			Dev-C++ help
		Reviewing the Annotated Program
			Examining the framework for all C++ programs
			Clarifying source code with comments
			Basing programs on C++ statements
			Writing declarations
			Generating output
		Calculating Expressions
			Storing the results of expression
			Examining the remainder of Conversion.cpp
	Chapter 2: Declaring Variables Constantly
		Declaring Variables
		Declaring Different Types of Variables
			Reviewing the limitations of integers in C++
			Solving the truncation problem
			Looking at the limits of floating-point numbers
		Declaring Variable Types
			Types of constants
			Special characters
		Are These Calculations Really Logical?
		Mixed Mode Expressions
	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
			Storing logical values
			Using logical int variables
			Be careful performing logical operations on floating-point variables
		Expressing Binary Numbers
			The decimal number system
			Other number systems
			The binary number system
		Performing Bitwise Logical Operations
			The single bit operators
			Using the bitwise operators
			A simple test
			Do something logical with logical calculations
	Chapter 5: Controlling Program Flow
		Controlling Program Flow with the Branch Commands
		Executing Loops in a Program
			Looping while a condition is true
			Using the autoincrement/autodecrement feature
			Using the for loop
			Avoiding the dreaded infinite loop
			Applying special loop controls
		Nesting Control Commands
		Switching to a Different Subject?
Part II: Becoming a Functional C++ Programmer
	Chapter 6: Creating Functions
		Writing and Using a Function
			Defining the sumSequence( ) function
			Calling the function sumSequence( )
			Divide and conquer
		Understanding the Details of Functions
			Understanding simple functions
			Understanding functions with arguments
		Overloading Function Names
		Defining Function Prototypes
		Variable Storage Types
		Including Include Files
	Chapter 7: Storing Sequences in Arrays
		Considering the Need for Arrays
			Using an array
			Initializing an array
			Accessing too far into an array
			Using arrays
			Defining and using arrays of arrays
		Using Arrays of Characters
			Creating an array of characters
			Creating a string of characters
		Manipulating Strings with Character
		String-ing Along Variables
	Chapter 8: Taking a First Look at C++ Pointers
		Variable Size
		What's in an Address?
		Address Operators
		Using Pointer Variables
			Comparing pointers and houses
			Using different types of pointers
		Passing Pointers to Functions
			Passing by value
			Passing pointer values
			Passing by reference
		Making Use of a Block of Memory Called the Heap
			Limiting scope
			Examining the scope problem
			Providing a solution using the heap
	Chapter 9: Taking a Second Look at C++ Pointers
		Defining Operations on Pointer Variables
			Re-examining arrays in light of pointer variables
			Applying operators to the address of an array
			Expanding pointer operations to a string
			Justifying pointer-based string manipulation
			Applying operators to pointer types other than char
			Contrasting a pointer with an array
		Declaring and Using Arrays of Pointers
			Utilizing arrays of character strings
			Accessing the arguments to main( )
	Chapter 10: Debugging C++
		Identifying Types of Errors
		Choosing the WRITE Technique for the Problem
			Catching bug #1
			Catching bug #2
		Calling for the Debugger
			Defining the debugger
			Finding commonalities among us
			Running a test program
			Single-stepping through a program
Part III: Introduction to Classes
	Chapter 11: Examining Object-Oriented Programming
		Abstracting Microwave Ovens
			Preparing functional nachos
			Preparing object-oriented nachos
		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
	Chapter 13: Making Classes Work
		Activating Our Objects
			Simulating real-world objects
			Why bother with member functions?
		Adding a Member Function
			Creating a member function
			Naming class members
		Calling a Member Function
			Accessing a member function
			Accessing other members from a member function
		Scope Resolution (And I Don't Mean How Well Your Microscope Works)
		Defining a Member Function in the Class
		Keeping a Member Function After Class
		Overloading Member Functions
	Chapter 14: Point and Stare at Objects
		Defining Arrays of and Pointers to Simple Things
		Declaring Arrays of Objects
		Declaring Pointers to Objects
			Dereferencing an object pointer
			Pointing toward arrow pointers
		Passing Objects to Functions
			Calling a function with an object value
			Calling a function with an object pointer
			Calling a function by using the reference operator
		Why Bother with Either Pointers or References?
		Returning to the Heap
		Comparing Pointers to References
		Why Not Use References Rather Than Pointers?
		Linking Up with Linked Lists
			Performing other operations on a linked list
			Hooking up with a LinkedListData program
		A Ray of Hope: A List of Containers Linked to the C++ Library
	Chapter 15: Protecting Members: Do Not Disturb
		Protecting Members
			Why you need protected members
			Discovering how protected members work
		Making an Argument for Using Protected Members
			Protecting the internal state of the class
			Using a class with a limited interface
		Giving Non-Member Functions Access to Protected Members
	Chapter 16: "Why Do You Build Me Up,Just to Tear Me Down, Baby?"
		Creating Objects
		Using Constructors
			Why you need constructors
			Making constructors work
		Dissecting a Destructor
			Why you need the destructor
			Working with destructors
	Chapter 17: Making Constructive Arguments
		Outfitting Constructors with Arguments
			Justifying constructors
			Using a constructor
		Placing Too Many Demands on the Carpenter:Overloading the Constructor
		Defaulting Default Constructors
		Constructing Class Members
			Constructing a complex data member
			Constructing a constant data member
		Constructing the Order of Construction
			Local objects construct in order
			Static objects construct only once
			All global objects construct before main( )
			Global objects construct in no particular order
			Members construct in the order in which they are declared
			Destructors destruct in the reverse order of the constructors
	Chapter 18: Copying the Copy Copy Copy Constructor
		Copying an Object
			Why you need the copy constructor
			Using the copy constructor
		The Automatic Copy Constructor
		Creating Shallow Copies versus Deep Copies
		It's a Long Way to Temporaries
			Avoiding temporaries, permanently
			Referring to the copy constructor's referential argument
	Chapter 19: Static Members: Can Fabric Softener Help?
		Defining a Static Member
			Why you need static members
			Using static members
			Referencing static data members
			Uses for static data members
		Declaring Static Member Functions
		What Is This About, Anyway?
Part IV: Inheritance
	Chapter 20: Inheriting a Class
		Do I Need My Inheritance?
		How Does a Class Inherit?
			Using a subclass
			Constructing a subclass
			Destructing a subclass
		Having a HAS_A Relationship
	Chapter 21: 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 22: Factoring Classes
		Factoring
		Implementing Abstract Classes
			Describing the abstract class concept
			Making an honest class out of an abstract class
			Passing abstract classes
			Declaring pure virtual functions - is it really necessary?
		Factoring C++ Source Code
			Dividing the program - Student
			Defining a namespace
			Implementing Student
			Dividing the program - GraduateStudent
			Implementing an application
			Project file
			Creating a project file under Dev-C++
Part V: Optional Features
	Chapter 23: 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
		Protecting the Escape Hatch
	Chapter 24: Using Stream I/O
		How Stream I/O Works
		The fstream Subclasses
		Reading Directly from a Stream
		What's Up with endl?
		Using the strstream Subclasses
		Manipulating Manipulators
	Chapter 25: Handling Errors - Exceptions
		Justifying a New Error Mechanism?
		Examining the Exception Mechanism
		What Kinds of Things Can I Throw?
	Chapter 26: 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 27: Tempting C++ Templates
		Generalizing a Function into a Template
		Template Classes
		Do I Really Need Template Classes?
		Tips for Using Templates
	Chapter 28: Standardizing on the Standard Template Library
		The string Container
		The list Containers
		Iterators
		Using Maps
Part VI: The Part of Tens
	Chapter 29: Ten Ways to Avoid Adding Bugs to Your Program
		Enabling All Warnings and Error Messages
		Insisting on Clean Compiles
		Adopting a Clear and Consistent Coding Style
		Limiting the Visibility
		Commenting Your Code While You Write It
		Single-Stepping Every Path at Least Once
		Avoid Overloading Operators
		Heap Handling
		Using Exceptions to Handle Errors
		Avoiding Multiple Inheritance
	Chapter 30: The Ten Most Important Optional Features of Dev-C++
		Customize Editor Settings to Your Taste
		Highlight Matching Braces/Parentheses
		Enable Exception Handling
		Include Debugging Information (Sometimes)
		Create a Project File
		Customize the Help Menu
		Reset Breakpoints after Editing the File
		Avoid Illegal Filenames
		Include #include Files in Your Project
		Executing the Profiler
Appendix: About the CD
	System Requirements
	Using the CD with Microsoft Windows
	Using the CD with Linux
	What You'll Find
		Development tools
		Program source code
	If You've Got Problems (Of the CD Kind)
Index
Team DDU