Ivor Horton’s Beginning ANSI C++: The Complete Language

Ivor Horton s Beginning ANSI C++: The Complete Language, Third Edition
Contents at a Glance
Contents
About the Author
About the Technical Reviewer
Acknowledgments
Introduction
	Why C++?
	The Standard for C++
	Using the Book
Basic Ideas
	Programming Languages
		A Potted History
		Interpreted vs. Compiled Program Execution
		Libraries
	Why Is C++ Such a Great Language?
		The ANSI/ISO Standard for C++
	A Simple C++ Program
		Names
		Namespaces
	Keywords
	C++ Statements and Statement Blocks
		Code Presentation Style
	Program Structure
		Program Functions and Execution
	Creating an Executable from Your Source Files
		Compiling
		Linking
	C++ Source Characters
		The Universal Character Set
		Trigraph Sequences
		Escape Sequences
		Whitespace in Statements
	Documenting Your Programs
	The Standard Library
	Programming in C++
		Procedural and Object-Oriented Programming
	Summary
	Exercises
Basic Data Types and Calculations
	Data and Data Types
	Performing Simple Calculations
		Introducing Literals
		Integer Literals
		Integer Arithmetic
		Operator Precedence and Associativity
	Using Variables
		Variable Names
	Integer Variables
		Integer Variable Types
		Integer Ranges
		The Type of an Integer Literal
	The Assignment Operator
		Multiple Assignments
		Modifying the Value of a Variable
	Incrementing and Decrementing Integers
		Postfix Increment and Decrement Operations
	The const Keyword
	Numerical Functions for Integers
		Generating Random Numbers
	Floating-Point Operations
		Floating-Point Data Types
		Floating-Point Operations
		Working with Floating-Point Values
		Mathematical Functions
	Working with Characters
		Character Literals
		Initializing char Variables
		Working with Extended Character Sets
	Functional Notation for Initial Values
	Summary
	Exercises
More on Handling Basic Data Types
	Mixed Expressions
		Assignments and Different Types
		Explicit Casts
		Old-Style Casts
	Finding Out About Types
		Finding the Limits
	Bitwise Operators
		The Bitwise Shift Operators
		Logical Operations on Bit Patterns
	Enumerated Data Types
		Anonymous Enumerations
		Casting Between Integer and Enumeration Types
	Synonyms for Data Types
	The Lifetime of a Variable
		Automatic Variables
		Positioning Variable Declarations
		Global Variables
		Static Variables
	The volatile Type Modifier
	Declaring External Variables
	Precedence and Associativity
	Summary
	Exercises
Choices and Decisions in Your Programs
	Comparing Data Values
		Applying the Comparison Operators
		Comparing Floating Point Values
	The if Statement
		Nested if Statements
	The if-else Statement
		Nested if-else Statements
	Logical Operators
		Logical AND
		Logical OR
		Logical Negation
	The Conditional Operator
	The switch Statement
	Unconditional Branching
	Decision Statement Blocks and Variable Scope
	Summary
	Exercises
Loops: Repeating One or More Statements
	Understanding Loops
	The while Loop
	The do-while Loop
		More Complex while Loop Conditions
	The for Loop
		Loops and Variable Scope
		Controlling a for Loop with Floating-Point Values
		Using More Complex Loop Control Expressions
	Nested Loops
	Skipping Loop Iterations
	Breaking Out of a Loop
		Indefinite Loops
	Summary
	Exercises
Arrays and Strings
	Data Arrays
		Using an Array
		Initializing Arrays
		Arrays of Characters
	Multidimensional Arrays
		Initializing Multidimensional Arrays
		Multidimensional Character Arrays
	A Better Class of String
		Declaring string Objects
		Operations with String Objects
		Accessing Characters in a String
		Accessing Substrings
		Comparing Strings
		Searching a String
		Modifying a String
	Arrays of Type string
	Wide-Character Strings
	Summary
	Exercises
Pointers
	What Is a Pointer?
	Declaring a Pointer
		Using Pointers
	Initializing Pointers
		Initializing Pointers to Type char
	Constant Pointers and Pointers to Constants
	Pointers and Arrays
		Pointer Arithmetic
		Using Pointer Notation with an Array Name
		Using Pointers with Multidimensional Arrays
		Operations on C-Style Strings
	Dynamic Memory Allocation
		The Free Store (aka the Heap)
		The Operators new and delete
		Dynamic Memory Allocation for Arrays
		Hazards of Dynamic Memory Allocation
		Converting Pointers
	Summary
	Exercises
Programming with Functions
	Segmenting Your Programs
		Why You Should Segment Your Programs into Functions
	Understanding Functions
		Defining a Function
		Function Declarations
	Passing Arguments to a Function
		The Pass-by-Value Mechanism
		The Pass-by-Reference Mechanism
		Arguments to main()
	Default Argument Values
		Multiple Default Parameter Values
	Returning Values from a Function
		Returning a Pointer
		Returning a Reference
		Returning a New Variable from a Function
	Inline Functions
	Static Variables
	Summary
	Exercises
More on Functions
	Function Overloading
		The Signature of a Function
		Overloading and Pointer Parameters
		Overloading and Reference Parameters
		Overloading and const Parameters
		Overloading and Default Argument Values
	A Sausage Machine for Functions
		Creating Instances of a Function Template
		Explicitly Specifying a Template Parameter
		Specialization of Templates
		Function Templates and Overloading
		Templates with Multiple Parameters
	Pointers to Functions
		Declaring Pointers to Functions
		Passing a Function as an Argument
		Arrays of Pointers to Functions
	Recursion
		Using Recursion
	Summary
	Exercises
Program Files and Preprocessing Directives
	Working with Program Files
		The Scope of a Name
		The “One Definition” Rule
		Program Files and Linkage
		External Names
	Namespaces
		The Global Namespace
		Defining a Namespace
		Functions and Namespaces
		Function Templates and Namespaces
		Extension Namespaces
		Unnamed Namespaces
		Namespace Aliases
		Nested Namespaces
	Preprocessing Your Source Code
		Including Header Files in Your Programs
		Substitutions in Your Program
		Macro Substitutions
		Preprocessing Directives on Multiple Lines
		Strings As Macro Arguments
		Joining the Arguments in a Macro Expansion
	Logical Preprocessing Directives
		The Logical #if Directive
		Directives Testing for Specific Values
		Multiple Choice Code Selection
		Standard Preprocessing Macros
		The #error and #pragma Directives
	Debugging Methods
		Integrated Debuggers
		Preprocessing Directives in Debugging
		Using the assert() Macro
	Summary
	Exercises
Creating Your Own Data Types
	Introducing Objects
	The Structure in C++
		Understanding Structures
		Defining a Structure Type
		Creating Objects of a Structure Type
		Accessing the Members of a Structure Object
		Using Pointers with a Structure
	Understanding Unions
		Declaring Unions
		Anonymous Unions
	More Complex Structures
		Structures with Structures As Members
	Summary
	Exercises
Classes: Defining Your Own Data Types
	Classes and Object-Oriented Programming
		Encapsulation
		Inheritance
		Polymorphism
		Terminology
	Defining a Class
	Constructors
		Placing Constructor Definitions Outside the Class
		The Default Constructor
		Default Initialization Values
		Using an Initializer List in a Constructor
		Use of the explicit Keyword
	Private Members of a Class
		Accessing Private Class Members
		The Default Copy Constructor
	Friends
		The Friend Functions of a Class
		Friend Classes
	The Pointer Named this
	Objects That Are const and const Member Functions
		Mutable Data Members of a Class
		Casting Away const
	Arrays of Objects of a Class
	The Size of a Class Object
	Static Members of a Class
		Static Data Members of a Class
		Static Member Functions of a Class
	Summary
	Exercises
Class Operations
	Pointers and References to Class Objects
	Pointers As Data Members
		Defining the Package Class
		Defining the TruckLoad Class
		Implementing the TruckLoad Class
	Controlling Access to a Class
		Nested Classes
	The Importance of the Copy Constructor
		Implementing the Copy Constructor
	Dynamic Memory Allocation Within an Object
		What Is a Destructor?
		Defining the Destructor
		The Default Destructor
		Implementing a Destructor
	References in Classes
		References As Members of a Class
	Summary
	Exercises
Operator Overloading
	Implementing Operators for Your Classes
		Operator Overloading
		Operators That Can Be Overloaded
		Implementing an Overloaded Operator
		Global Operator Functions
		Implementing Full Support for an Operator
		Operator Function Idioms
		Overloading the Assignment Operator
		Overloading the Arithmetic Operators
		Overloading the Subscript Operator
		Overloading Type Conversions
		Overloading the Increment and Decrement Operators
		Smart Pointers
		Overloading Operators new and delete
	Summary
	Exercises
Inheritance
	Classes and Object-Oriented Programming
		Hierarchies
	Inheritance in Classes
		Inheritance vs. Aggregation
		Deriving Classes from a Base Class
	Access Control Under Inheritance
	Declaring Members of a Class As protected
	The Access Level of Inherited Class Members
		Using Access Specifiers in Class Hierarchies
		Changing the Access Specification of Inherited Members
	Constructor Operation in a Derived Class
		The Copy Constructor in a Derived Class
	Destructors Under Inheritance
		The Order in Which Destructors Are Called
	Duplicate Member Names
		Duplicate Function Member Names
	Multiple Inheritance
		Multiple Base Classes
		Inherited Member Ambiguity
		Repeated Inheritance
		Virtual Base Classes
	Converting Between Related Class Types
	Summary
	Exercises
Virtual Functions and Polymorphism
	Understanding Polymorphism
		Using a Base Class Pointer
		Calling Inherited Functions
		Virtual Functions
		Default Argument Values in Virtual Functions
		Using References to Call Virtual Functions
		Calling the Base Class Version of a Virtual Function
		Converting Between Pointers to Class Objects
		Dynamic Casts
	The Cost of Polymorphism
	Pure Virtual Functions
		Abstract Classes
		Indirect Abstract Base Classes
	Destroying Objects Through a Pointer
		Virtual Destructors
	Identifying Types at Runtime
	Pointers to Class Members
		Pointers to Data Members
		Pointers to Member Functions
	Summary
	Exercises
Program Errors and Exception Handling
	Handling Errors
	Understanding Exceptions
		Throwing an Exception
		Code That Causes an Exception to Be Thrown
		Nested try Blocks
	Class Objects As Exceptions
		Matching a Catch Handler to an Exception
		Catching Derived Class Exceptions with a Base Class Handler
		Rethrowing an Exception
		Catching All Exceptions
	Functions That Throw Exceptions
		Function try Blocks
		Throwing Exceptions in Constructors
		Exceptions and Destructors
	Standard Library Exceptions
		Standard Library Exception Classes
		Using Standard Exceptions
	Summary
	Exercises
Using Class Templates To Create Families of Classes
	Understanding Class Templates
		Applications of Class Templates
	Defining Class Templates
		Template Parameters
		A Simple Class Template
		Instantiating a Class Template
		Static Members of a Class Template
		Non-Type Class Template Parameters
		Non-Type Parameter Example
		Default Template Argument Values
	Explicit Template Instantiation
	Friends of Class Templates
	Special Cases
		Partial Template Specialization
	Class Templates with Nested Classes
		Defining Function Templates for Members
	More Advanced Class Templates
	Summary
	Exercises
Input and Output Operations
	Input and Output in C++
		Understanding Streams
		Advantages of Using Streams
	Stream Classes
		Standard Streams
		Stream Insertion and Extraction Operations
		Stream Manipulators
	File Streams
		Writing to a File
		Reading from a File
		Setting the File Open Mode
	Unformatted Stream Operations
		Unformatted Stream Input
		Unformatted Stream Output
	Errors in Stream Input/Output
		Input/Output Errors and Exceptions
	Using Binary Mode Stream Operations
		Writing Numeric Data in Binary Form
	Read/Write Operations on a Stream
		Random Access to a Stream
	String Streams
	Objects and Streams
		Overloading the Insertion Operator for Class Objects
		Overloading the Extraction Operator for Class Objects
		More Complex Objects in Streams
	Summary
	Exercises
Introducing the Standard Template Library
	An Introduction to the STL Architecture
		STL Components
		STL Headers
	Using the vector Container
		Creating a vector Container
		Accessing Elements in a vector Container
		Basic Operations on a vector Container
		Using vector Containers with Array Operations
		Using an Input Stream Iterator
	Creating Your Own Iterators
		Passing Iterators to an Algorithm
		STL Iterator Type Requirements
		The STL Iterator Member Function Requirements
		Insert Iterators
	The list Container
		Creating list Containers
		Accessing Elements in a List
		Operations on Lists
	The Associative Containers
		Using a map Container
	Performance and Specialization
	Summary
	Exercises
ASCII Codes
C++ Keywords
Standard Library Headers
	Language Support
	Input/Output
	Diagnostics
	General Utilities
	Strings
	Containers
	Iterator Support
	General Purpose Algorithms
	Numerical Operations
	Localization
Operator Precedence and Associativity
Understanding Binary and Hexadecimal Numbers
	Binary Numbers
	Hexadecimal Numbers
	Negative Binary Numbers
		Big-Endian and Little-Endian Systems
Example Project
	Outline
		Improving the Project Specification
	Developer’s Notes
		The Person Class
		The
		Classes
		The Container
		Saving and Restoring Data
Index