Beginning C++

Contents at a Glance

Contents

About the Author

About the Technical Reviewer

Introduction

Chapter 1: Basic Ideas

Modern C++

C++ Program Concepts

Comments and Whitespace

Preprocessing Directives and Header Files

Functions

Statements

Data Input and Output

return Statements

Namespaces

Names and Keywords

Classes and Objects

Templates

Program Files

Standard Libraries

Code Presentation Style

Creating an Executable

Representing Numbers

Binary Numbers

Hexadecimal Numbers

Negative Binary Numbers

Octal Values

Big-Endian and Little-Endian Systems

Floating-Point Numbers

Representing Characters

ASCII Codes

UCS and Unicode

C++ Source Characters

Trigraph Sequences

Escape Sequences

Procedural and Object-Oriented Programming

Summary

Chapter 2: Introducing Fundamental Types of Data

Variables, Data, and Data Types

Defining Integer Variables

Defining Variables with Fixed Values

Integer Literals

Decimal Integer Literals

Hexadecimal Literals

Octal Literals

Binary Literals

Calculations with Integers

More on Assignment Operations

The op= Assignment Operators

using Declarations and Directives

The sizeof Operator

Incrementing and Decrementing Integers

Postfix Increment and Decrement Operations

Defining Floating-Point Variables

Floating-Point Literals

Floating-Point Calculations

Mathematical Functions

Formatting Stream Output

Mixed Expressions and Type Conversion

Explicit Type Conversion

Old-Style Casts

Finding the Limits

Working with Character Variables

Working with Unicode Characters

The auto Keyword

Lvalues and Rvalues

Summary

Chapter 3: Working with Fundamental Data Types

Operator Precedence and Associativity

Bitwise Operators

The Bitwise Shift Operators

Shifting Signed Integers

Logical Operations on Bit Patterns

Using the Bitwise AND

Using the Bitwise OR

Using the Bitwise Exclusive OR

Enumerated Data Types

Old-Style Enumerations

Synonyms for Data Types

The Lifetime of a Variable

Positioning Variable Definitions

Global Variables

Static Variables

External Variables

Summary

Chapter 4: Making Decisions

Comparing Data Values

Applying the Comparison Operators

Comparing Floating Point Values

The if Statement

Nested if Statements

Code-Neutral Character Handling

The if-else Statement

Nested if-else Statements

Understanding Nested ifs

Logical Operators

Logical AND

Logical OR

Logical Negation

The Conditional Operator

The switch Statement

Unconditional Branching

Statement Blocks and Variable Scope

Summary

Chapter 5: Arrays and Loops

Arrays

Using an Array

Understanding Loops

The for Loop

Avoiding Magic Numbers

Defining the Array Size with the Initializer List

Determining the Size of an Array

Controlling a for Loop with Floating-Point Values

More Complex for Loop Control Expressions

The Comma Operator

The Ranged-based for Loop

The while Loop

Allocating an Array at Runtime

The do-while Loop

Nested Loops

Skipping Loop Iterations

Breaking Out of a Loop

Indefinite Loops

Arrays of Characters

Multidimensional Arrays

Initializing Multidimensional Arrays

Setting Dimensions by Default

Multidimensional Character Arrays

Alternatives to Using an Array

Using array Containers

Using std::vector Containers

The Capacity and Size of a Vector

Deleting Elements from a Vector container

Summary

Chapter 6: Pointers and References

What Is a Pointer ?

The Address-Of Operator

The Indirection Operator

Why Use Pointers ?

Pointers to Type char

Arrays of Pointers

Constant Pointers and Pointers to Constants

Pointers and Arrays

Pointer Arithmetic

The Difference between Pointers

Using Pointer Notation with an Array Name

Dynamic Memory Allocation

The Stack and the Heap

Using the new and delete Operators

Dynamic Allocation of Arrays

Member Selection through a Pointer

Hazards of Dynamic Memory Allocation

Memory Leaks

Fragmentation of the Free Store

Raw Pointers and Smart Pointers

Using unique_ptr Pointers

Using shared_ptr Pointers

Comparing shared_ptr Objects

weak_ptr Pointers

Understanding References

Defining lvalue References

Using a Reference Variable in a Range-Based for Loop

Defining rvalue References

Summary

Chapter 7: Working with Strings

A Better Class of String

Defining string Objects

Operations with String Objects

Concatenating Strings

Accessing Characters in a String

Accessing Substrings

Comparing Strings

The compare(?) Function

Comparisons Using substr(?)

Searching Strings

Searching for any of a Set of Characters

Searching a String Backwards

Modifying a String

Inserting a String

Replacing a Substring

Removing Characters from a String

Strings of International Characters

Strings of wchar_t Characters

Objects that contain Unicode Strings

Raw String Literals

Summary

Chapter 8: Defining Functions

Segmenting Your Programs

Functions in Classes

Characteristics of a Function

Defining Functions

The Function Body

Return Values

How the return Statement Works

Function Declarations

Function Prototypes

Passing Arguments to a Function

Pass-by-Value

Passing a Pointer to a Function

Passing an Array to a Function

const Pointer Parameters

Passing a Multidimensional Array to a Function

Pass-by-Reference

References Can Be Risky

Improving the Program

Simplifying Code using Type Aliases

References versus Pointers

Arguments to main()

Default Argument Values

Multiple Default Parameter Values

Returning Values from a Function

Returning a Pointer

Returning a Reference

Inline Functions

Static Variables

Function Overloading

Overloading and Pointer Parameters

Overloading and Reference Parameters

Overloading and const Parameters

Overloading with const Pointer Parameters

Overloading and const Reference Parameters

Overloading and Default Argument Values

A Sausage Machine for Functions

Creating Instances of a Function Template

Explicit Template Argument

Function Template Specialization

Function Templates and Overloading

Function Templates with Multiple Parameters

Non-Type Template Parameters

Trailing Return Types

Pointers to Functions

Defining Pointers to Functions

Recursion

Applying Recursion

The Quicksort Algorithm

The main() Function

The extract_words() Function

The swap() Function

The sort() function

The max_word_length() Function

The show_words() Function

Summary

Chapter 9: Lambda Expressions

Introducing Lambda Expressions

Defining a Lambda Expression

Naming a Lambda Expression

Passing a Lambda Expression to a Function

Function Templates that Accept Lambda Expression Arguments

A Function Parameter Type for Lambda Arguments

Using the std::function Template Type

The Capture Clause

Capturing Specific Variables

Using Lambda Expressions in a Template

Recursion in Lambda Expressions

Summary

Chapter 10: Program Files and Preprocessing Directives

Understanding Translation Units

The “One Definition” Rule

Program Files and Linkage

Determining Linkage for a Name

External Names

const Variables with External Linkage

Preprocessing Your Source Code

Defining Preprocessing Identifiers

Undefining an Identifier

Including Header Files

Preventing Duplication of Header File Contents

Namespaces

The Global Namespace

Defining a Namespace

Applying using Declarations

Functions and Namespaces

Unnamed Namespaces

Namespace Aliases

Nested Namespaces

Logical Preprocessing Directives

The Logical #if Directive

Testing for Specific Identifier Values

Multiple Choice Code Selection

Standard Preprocessing Macros

Debugging Methods

Integrated Debuggers

Preprocessing Directives in Debugging

Using the assert(?) Macro

Switching Off assert() Macros

Static Assertions

Summary

Chapter 11: Defining Your Own Data Types

Classes and Object-Oriented Programming

Encapsulation

Data Hiding

Inheritance

Polymorphism

Terminology

Defining a Class

Constructors

Defining Constructors Outside the Class

Default Constructor Parameter Values

Using a Constructor Initialization List

Use of the explicit Keyword

Delegating Constructors

The Copy Constructor

Implementing the Copy Constructor

Reference Parameters

Accessing Private Class Members

Friends

The Friend Functions of a Class

Friend Classes

The this Pointer

Returning this from a Function

const Objects and const Member Functions

Casting Away const

Arrays of Class Objects

The Size of a Class Object

Static Members of a Class

Static Data Members

Accessing Static Data Members

A Static Data Member of the Class Type

Static Function Members

Destructors

Pointers and References to Class Objects

Using Pointers As Class Members

Defining the Package Class

Defining the Truckload Class

Implementing the Truckload Class

Nested Classes

Summary

Chapter 12: Operator Overloading

Implementing Operators for a Class

Operator Overloading

Operators That Can Be Overloaded

Implementing an Overloaded Operator

Global Operator Functions

Implementing Full Support for an Operator

Implementing All Comparison Operators in a Class

Operator Function Idioms

Default Class Members

Defining the Destructor

When to Define a Copy Constructor

Implementing the Assignment Operator

Implementing Move Operations

Overloading the Arithmetic Operators

Improving Output Operations

Implementing One Operator in Terms of Another

Overloading the Subscript Operator

Lvalues and the Overloaded Subscript Operator

Potential Ambiguities with Conversions

Overloading Type Conversions

Overloading the Increment and Decrement Operators

Function Objects

Summary

Chapter 13: Inheritance

Classes and Object-Oriented Programming

Hierarchies

Inheritance in Classes

Inheritance vs. Aggregation

Deriving Classes

protected Members of a Class

The Access Level of Inherited Class Members

Choosing 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

The Default Constructor in a Derived Class

Inheriting Constructors

Destructors Under Inheritance

The Order in Which Destructors Are Called

Duplicate Data 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

Chapter 14: Polymorphism

Understanding Polymorphism

Using a Base Class Pointer

Calling Inherited Functions

Virtual Functions

Requirements for Virtual Function Operation

Virtual Functions and Class Hierarchies

Using override

Using final

Access Specifiers and Virtual Functions

Default Argument Values in Virtual Functions

Virtual Function Calls with Smart Pointers

Using References to Call Virtual Functions

Calling the Base Class Version of a Virtual Function

Converting Between Pointers to Class Objects

Dynamic Casts

Casting Pointers Dynamically

Converting References

Determining the Polymorphic Type

The Cost of Polymorphism

Pure Virtual Functions

Abstract Classes

Abstract Classes As Interfaces

Indirect Abstract Base Classes

Destroying Objects Through a Pointer

Virtual Destructors

Summary

Chapter 15: Runtime Errors and Exceptions

Handling Errors

Understanding Exceptions

Throwing an Exception

The Exception Handling Process

Unhandled Exceptions

Code That Causes an Exception to Be Thrown

Nested try Blocks

How It Works

Class Objects as Exceptions

Matching a Catch Handler to an Exception

How It Works

Catching Derived Class Exceptions with a Base Class Handler

Rethrowing Exceptions

Catching All Exceptions

Functions That Throw Exceptions

Function try Blocks

Functions That Don’t Throw Exceptions

Constructor try Blocks

Exceptions and Destructors

Standard Library Exceptions

The Exception Class Definitions

Using Standard Exceptions

Deriving your own Exception Classes

Summary

Chapter 16: Class Templates

Understanding Class Templates

Defining Class Templates

Template Parameters

A Simple Class Template

Defining Function Members of a Class Template

Constructor Templates

The Destructor Template

Subscript Operator Templates

The Assignment Operator Template

Instantiating a Class Template

Static Members of a Class Template

Non-Type Class Template Parameters

Templates for Function Members with Non-Type Parameters

Arguments for Non-Type Parameters

Pointers and Arrays as Non-Type Parameters

Default Values for Template Parameters

Explicit Template Instantiation

Special Cases

Using static_assert(?) in a Class Template

Defining a Class Template Specialization

Partial Template Specialization

Choosing between Multiple Partial Specializations

Friends of Class Templates

Class Templates with Nested Classes

Function Templates for Stack Members

Summary

Chapter 17: File Input and Output

Input and Output in C++

Understanding Streams

Data Transfer Modes

Text Mode Operations

Binary Mode Operations

Advantages of Using Streams

Stream Classes

Standard Stream Objects

Stream Insertion and Extraction Operations

Stream Extraction Operations

Stream Insertion Operations

Stream Manipulators

Manipulators with Arguments

File Streams

Writing a File in Text Mode

Reading a File in Text Mode

Checking the State of a File Stream

Reading the File

Setting the Stream Open Mode

Managing the Current Stream Position

Unformatted Stream Operations

Unformatted Stream Input

Unformatted Stream Output

Errors in Stream Input/Output

Input/Output Errors and Exceptions

Stream Operations in Binary Mode

Writing Numeric Data in Binary

File Read/Write Operations

Random Access to a File

Random Access to a Binary Stream

Random File Operations in Practice

Implementing the Constructor

Checking for the Existence of a File

Finding a Prime that follows a Prime

Checking for a Prime

Implementing the Subscript Operator

Using the Primes Class

String Streams

Objects and Streams

Using the Insertion Operator with Objects

Using the Extraction Operator with Objects

Object I/O in Binary Mode

More Complex Objects in Streams

Summary

Index