Contents

About the Author

About the Technical Reviewers

Acknowledgments

Introduction

 Exploration 1: Honing Your Tools

Ray’s Recommendations

Microsoft Windows

Macintosh OS X

Everyone Else

Read the Documentation

Your First Program

 Exploration 2: Reading C++ Code

Comments

Headers

Main Program

Variable Definitions

Statements

Output

 Exploration 3: Integer Expressions

 Exploration 4: Strings

 Exploration 5: Simple Input

 Exploration 6: Error Messages

Misspelling

Bogus Character

Unknown Operator

Unknown Name

Symbol Errors

Fun with Errors

 Exploration 7: For Loops

Bounded Loops

Initialization

Condition

Postiteration

How a for Loop Works

Your Turn

 Exploration 8: Formatted Output

The Problem

Field Width

Fill Character

std Prefix

Alignment

Exploring Formatting

Alternative Syntax

On Your Own

 Exploration 9: Arrays and Vectors

Vectors for Arrays

Vectors

Iterators

 Exploration 10: Algorithms and Iterators

Algorithms

Member Types

A Simpler Loop

Using Iterators and Algorithms

 Exploration 11: Increment and Decrement

Increment

Decrement

 Exploration 12: Conditions and Logic

I/O and bool

Boolean Type

Logic Operators

Old-Fashioned Syntax

Comparison Operators

 Exploration 13: Compound Statements

Statements

Local Definitions and Scope

Definitions in for Loop Headers

 Exploration 14: Introduction to File I/O

Reading Files

Writing Files

 Exploration 15: The Map Data Structure

Using Maps

Pairs

Searching in Maps

 Exploration 16: Type Synonyms

typedef Declarations

Common typedefs

Type Aliases

 Exploration 17: Characters

Character Type

Character I/O

Newlines and Portability

Character Escapes

 Exploration 18: Character Categories

Character Sets

Character Categories

Locales

 Exploration 19: Case-Folding

Simple Cases

Harder Cases

 Exploration 20: Writing Functions

Functions

Function Call

Declarations and Definitions

Counting Words—Again

The main( ) Function

 Exploration 21: Function Arguments

Argument Passing

Pass-by-Reference

const References

const_iterator

Multiple Output Parameters

 Exploration 22: Using Algorithms

Transforming Data

Predicates

Other Algorithms

 Exploration 23: Unnamed Functions

Lambdas

Naming an Unnamed Function

Capturing Local Variables

const Capture

Return Type

 Exploration 24: Overloading Function Names

Overloading

bool is_alpha(char ch)

 Exploration 25: Big and Little Numbers

The Long and Short of It

Long Integers

Short Integers

Integer Literals

Byte-Sized Integers

Type Casting

Make Up Your Own Literals

Integer Arithmetic

Overload Resolution

 Exploration 26: Very Big and Very Little Numbers

Floating-Point Numbers

Floating-Point Literals

Floating-Point Traits

Floating-Point I/O

 Exploration 27: Documentation

Doxygen

Structured Comments

Documentation Tags and Markdown

Using Doxygen

 Exploration 28: Project 1: Body-Mass Index

Hints

 Exploration 29: Custom Types

Defining a New Type

Member Functions

Constructors

Overloading Constructors

 Exploration 30: Overloading Operators

Comparing Rational Numbers

Arithmetic Operators

Math Functions

 Exploration 31: Custom I/O Operators

Input Operator

Output Operator

Error State

 Exploration 32: Assignment and Initialization

Assignment Operator

Constructors

Putting It All Together

 Exploration 33: Writing Classes

Anatomy of a Class

Member Functions

Constructor

Defaulted and Deleted Constructors

 Exploration 34: More About Member Functions

Revisiting Project 1

Const Member Functions

 Exploration 35: Access Levels

Public vs. Private

class vs. struct

Plain Old Data

Public or Private?

 Exploration 36: Introduction to Object-Oriented Programming

Books and Magazines

Classification

Inheritance

Liskov’s Substitution Principle

Type Polymorphism

 Exploration 37: Inheritance

Deriving a Class

Member Functions

Destructors

Access Level

Programming Style

 Exploration 38: Virtual Functions

Type Polymorphism

Virtual Functions

References and Slices

Pure Virtual Functions

Virtual Destructors

 Exploration 39: Classes and Types

Classes vs. typedefs

Value Types

Copying

Assigning

Moving

Comparing

Resource Acquisition Is Initialization

 Exploration 40: Declarations and Definitions

Declaration vs. Definition

inline Functions

Variable Declarations and Definitions

Static Variables

Static Data Members

Declarators

 Exploration 41: Using Multiple Source Files

Multiple Source Files

Declarations and Definitions

#include Files

Quotes and Brackets

Nested #include Directives

Include Guards

Forward Declarations

Documentation

extern Variables

inline Functions

One-Definition Rule

 Exploration 42: Function Objects

The Function Call Operator

Function Objects

 Exploration 43: Useful Algorithms

Searching

Linear Search Algorithms

Binary Search Algorithms

Comparing

Rearranging Data

Copying Data

Deleting Elements

Iterators

 Exploration 44: Iterators

Kinds of Iterators

Input Iterators

Output Iterators

Forward Iterators

Bidirectional Iterators

Random Access Iterators

Working with Iterators

const_iterator vs. const iterator

Error Messages

Specialized Iterators

 Exploration 45: Exceptions

Introducing Exceptions

Catching Exceptions

Throwing Exceptions

Program Stack

Standard Exceptions

I/O Exceptions

Custom Exceptions

Don’t Throw Exceptions

Exceptional Advice

 Exploration 46: More Operators

Conditional Operator

Short-Circuit Operators

Comma Operator

Arithmetic Assignment Operators

Increment and Decrement

 Exploration 47: Project 2: Fixed-Point Numbers

value_type

places

places10

fixed( )

fixed(value_type integer, value_type fraction)

fixed(double val)

to_string( )

round( )

integer( )

fraction( )

 Exploration 48: Function Templates

Generic Functions

Using Function Templates

Writing Function Templates

Template Parameters

Template Arguments

Declarations and Definitions

Member Function Templates

 Exploration 49: Class Templates

Parameterizing a Type

Parameterizing the rational Class

Using Class Templates

Overloaded Operators

Mixing Types

 Exploration 50: Template Specialization

Instantiation and Specialization

Custom Comparators

Specializing Function Templates

Traits

 Exploration 51: Partial Template Specialization

Degenerate Pairs

Partial Specialization

Partially Specializing Function Templates

Value Template Parameters

 Exploration 52: Names and Namespaces

Namespaces

Nested Namespaces

Global Namespace

The std Namespace

Using Namespaces

The using Directive

The using Declaration

The using Declaration in a Class

Unnamed Namespaces

Name Lookup

 Exploration 53: Containers

Properties of Containers

Member Types

What Can Go into a Container

Inserting and Erasing

Inserting in a Sequence Container

Erasing from a Sequence Container

Inserting in an Associative Container

Erasing from an Associative Container

Exceptions

Iterators and References

Sequence Containers

The array Class Template

The deque Class Template

The list Class Template

The vector Class Template

Associative Containers

 Exploration 54: Locales and Facets

The Problem

Locales to the Rescue

Locales and I/O

Facets

Character Categories

Collation Order

 Exploration 55: International Characters

Why Wide?

Using Wide Characters

Wide Strings

Wide Character I/O

Multi-Byte Character Sets

Unicode

Universal Character Names

Unicode Difficulties

 Exploration 56: Text I/O

File Modes

String Streams

Text Conversion

 Exploration 57: Project 3: Currency Type

 Exploration 58: Pointers

A Programming Problem

The Solution

Addresses vs. Pointers

Dependency Graphs

 Exploration 59: Dynamic Memory

Allocating Memory

Freeing Memory

Pointer to Nothing

Implementing Standard Containers

Adding Variables

Special Member Functions

 Exploration 60: Moving Data with Rvalue References

Temporary Objects

Lvalues, Rvalues, and More

Implementing Move

Rvalue or Lvalue?

Special Member Functions

 Exploration 61: Exception-Safety

Memory Leaks

Exceptions and Dynamic Memory

Automatically Deleting Pointers

Exceptions and Constructors

 Exploration 62: Old-Fashioned Arrays

C-Style Arrays

Array Limitations

Dynamically Allocating an Array

The array Type

Multidimensional Arrays

C-Style Strings

Command-Line Arguments

Pointer Arithmetic

 Exploration 63: Smart Pointers

Revisiting unique_ptr

Copyable Smart Pointers

Smart Arrays

Pimpls

Iterators

 Exploration 64: Working with Bits

Integer As a Set of Bits

Bitmasks

Shifting Bits

Safe Shifting with Unsigned Types

Signed and Unsigned Types

Unsigned Literals

Type Conversions

Overflow

Introducing Bitfields

Portability

The bitset Class Template

 Exploration 65: Enumerations

Scoped Enumerations

Unscoped Enumerations

Strings and Enumerations

Revisiting Projects

 Exploration 66: Multiple Inheritance

Multiple Base Classes

Virtual Base Classes

Java-Like Interfaces

Interfaces vs. Templates

Mix-Ins

Protected Access Level

 Exploration 67: Traits and Policies

Case Study: Iterators

Iterator Traits

Type Traits

Case Study: char_traits

Policy-Based Programming

 Exploration 68: Names, Namespaces, and Templates

Common Rules

Name Lookup in Templates

Three Kinds of Name Lookup

Member Access Operators

Qualified Name Lookup

Unqualified Name Lookup

Argument-Dependent Lookup

 Exploration 69: Overloaded Functions and Operators

Type Conversion

Review of Overloaded Functions

Overload Resolution

Ranking Functions

List Initialization

Tie-Breakers

Default Arguments

 Exploration 70: Metaprogramming

Use constexpr for Compile-Time Values

Variable-Length Template Argument Lists

Types as Values

Conditional Types

Checking Traits

Substitution Failure Is Not An Error (SFINAE)

 Exploration 71: Project 4: Calculator

Index