Exploring C++ 11

Contents at a Glance

Contents

About the Author

About the Technical Reviewers

Acknowledgment

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)

bool is_alpha(std::string const& str)

char to_lower(char ch)

std::string to_lower(std::string str)

char to_upper(char ch)

std::string to_upper(std::string str)

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

@b word

@brief one-sentence-description

@c word

@em word

@file file name

@link entity text @endlink

@mainpage title

@p name

@par title

@param name description

@post postcondition

@pre precondition

@return description

@see xref

@ &, @@, @\, @%, @<

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

value_type

key_type

reference

const_reference

iterator

const_iterator

size_type

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