Thinking in C++ 2nd ed (Beta) Version TICA18 - Contents

Dynamic storage allocation

4: Data abstraction

A tiny C-like library

Header file etiquette

Importance of header files

The multiple-declaration problem

The preprocessor directives #define, #ifdef and #endif

A standard for header files

Namespaces in headers

Using headers in projects

Nested structures

Global scope resolution

Modifying Stash to use access control

answers:

5: Hiding the implementation

Modifying Stack to use access control

Handle classes

Hiding the implementation

Reducing recompilation

Guaranteed initialization with the constructor

answers:

6: Initialization & cleanup

Guaranteed cleanup with the destructor

Elimination of the definition block

for loops

Storage allocation

Stash with constructors and destructors

Stack with constructors & destructors

Aggregate initialization

7: Function overloading & default arguments

More name decoration

Overloading on return values

Placeholder arguments

Choosing overloading vs. default arguments

8: Constants

const in header files

Assignment and type checking

Character array literals

Function arguments & return values

Passing by const value

Returning by const value

Temporaries

Passing and returning addresses

Standard argument passing

Classes

const in classes

The constructor initializer list

“Constructors” for built-in types

Compile-time constants in classes

The “enum hack” in old code

const objects & member functions

mutable: bitwise vs. memberwise const

9: Inline functions

Preprocessor pitfalls

Macros and access

Inline functions

Inlines inside classes

Access functions

Accessors and mutators

Stash & Stack with inlines

Inlines & the compiler

Limitations

Order of evaluation

Hidden activities in constructors & destructors

Forward referencing

Reducing clutter

More preprocessor features

Token pasting

Improved error checking

static variables inside functions

10: Name control

Static elements from C

static class objects inside functions

Static object destructors

Controlling linkage

Confusion

Other storage class specifiers

The using declaration

Static members in C++

Defining storage for static data members

static array initialization

Nested and local classes

static member functions

Static initialization dependency

What to do

Alternate linkage specifications

Argument-passing guidelines

11: ReferencesBE & the copy-constructor

Pointers in C++

References in C++

References in functions

const references

Pointer references

The copy-constructor

Passing & returning by value

Passing & returning large objects

Function-call stack frame

Re-entrancy

Bitcopy versus initialization

Copy-construction

Temporary objects

Default copy-constructor

Alternatives to copy-construction

Preventing pass-by-value

Functions that modify outside objects

12: BEOperator overloading

Warning & reassurance

Syntax

Overloadable operators

Unary operators

Increment & decrement

Binary operators

Arguments & return values

Return by value as const

return efficiency

Unusual operators

Operators you can’t overload

Nonmember operators

Basic guidelines

Overloading assignment

Behavior of operator=

Pointers in classes

Tracing the output

Automatic operator= creation

Automatic type conversion

Constructor conversion

Preventing constructor conversion

Operator conversion

Reflexivity

A perfect example: strings

Pitfalls in automatic type conversion

Hidden activities

Early examples redesigned

13: Dynamic object creation

Object creation

C’s approach to the heap

operator new

operator delete

A simple example

Memory manager overhead

Stash for pointers

A test

The stack

new & delete for arrays

Making a pointer more like an array

Running out of storage

Overloading new & delete

Overloading global new & delete

Overloading new & delete for a class

Overloading new & delete for arrays

14: Inheritance & composition

Composition syntax

Inheritance syntax

The constructor initializer list

Member object initialization

Built-in types in the initializer list

Combining composition & inheritance

Automatic destructor calls

Order of constructor & destructor calls

Name hiding

Functions that don’t automatically inherit

Choosing composition vs. inheritance

Subtyping

Specialization

private inheritance

Publicizing privately inherited members

protected

protected inheritance

Multiple inheritance

Incremental development

Upcasting

Why “upcasting”?

Downcasting

Upcasting and the copy-constructor (not indexed)

Composition vs. inheritance (revisited)

Pointer & reference upcasting

A crisis

Evolution of C++ programmers

15: Polymorphism & virtual functions

Upcasting

The problem

Function call binding

virtual functions

Extensibility

How C++ implements late binding

Storing type information

Picturing virtual functions

Under the hood

Installing the vpointer

Objects are different

Why virtual functions?

Abstract base classes and pure virtual functions

Pure virtual definitions

Inheritance and the VTABLE

Object slicing

virtual functions & constructors

Order of constructor calls

Behavior of virtual functions inside constructors

Destructors and virtual destructors

Virtuals in destructors

Non-inline function definitions

16: Introduction to templates

Containers & iterators

The need for containers

Overview of templates

The C approach

The Smalltalk approach

The template approach

Template syntax

Header files

The stack as a template

Constants in templates

Stash and stack as templates

The ownership problem

Stash as a template

stack as a template

Polymorphism & containers

BE a long journey

Part 2: The Standard C++ Library

Library overview

17: Strings

What’s in a string

Creating and initializing C++ strings

Initialization limitations

Operating on strings

Appending, inserting and concatenating strings

Replacing string characters

Simple character replacement using the STL replace( ) algorithm

Concatenation using non-member overloaded operators

Searching in strings

Finding in reverse

Finding first/last of a set

Removing characters from strings

Stripping HTML tags

Comparing strings

Indexing with [ ] vs. at( )

Using iterators

Iterating in reverse

Strings and character traits

18: Iostreams

Iostreams to the rescue

Sneak preview of operator overloading

Inserters and extractors

Manipulators

Common usage

Line-oriented input

Overloaded versions of get( )

Using get( ) with a streambuf

Seeking in iostreams

Creating read/write files

stringstreams

strstreams

User-allocated storage

Output strstreams

Automatic storage allocation

Proving movement

A better way

Output stream formatting

Internal formatting data

Format fields

Width, fill and precision

An exhaustive example

Formatting manipulators

Manipulators with arguments

Creating manipulators

Effectors

Iostream examples

Code generation

Maintaining class library source

Detecting compiler errors

A simple datalogger

Generating test data

Verifying & viewing the data

Counting editor

Breaking up big files

Nontype template arguments

19: Templates in depth

Default template arguments

The typename keyword

Typedefing a typename

Using typename instead of class

Function templates

A string conversion system

A memory allocation system

Type induction in function templates

Taking the address of a generated function template

Local classes in templates

Applying a function to an STL sequence

Template-templates

Member function templates

Why virtual member template functions are disallowed

Nested template classes

Template specializations

Full specialization

Partial Specialization

A practical example

Pointer specialization

Partial ordering of function templates

Design & efficiency

Preventing template bloat

Explicit instantiation

Explicit specification of template functions

Controlling template instantiation

The inclusion vs. separation models

The export keyword

Template programming idioms

The “curiously-recurring template”

Traits

STL reference documentation

20: STL Containers & Iterators

Containers and iterators

The Standard Template Library

The basic concepts

Containers of strings

Inheriting from STL containers

A plethora of iterators

Iterators in reversible containers

Iterator categories

Input: read-only, one pass

Output: write-only, one pass

Forward: multiple read/write

Bidirectional: operator--

Random-access: like a pointer

Is this really important?

Predefined iterators

IO stream iterators

Manipulating raw storage

Basic sequences: vector, list & deque

Basic sequence operations

vector

Cost of overflowing allocated storage

Inserting and erasing elements

deque

Converting between sequences

Cost of overflowing allocated storage

Checked random-access

list

Special list operations

list vs. set

Swapping all basic sequences

Robustness of lists

Performance comparison

set

Eliminating strtok( )

StreamTokenizer: a more flexible solution

A completely reusable tokenizer

Associative containers

Generators and fillers for associative containers

The magic of maps

A command-line argument tool

Multimaps and duplicate keys

Multisets

Combining STL containers

Cleaning up containers of pointers

Creating your own containers

Freely-available STL extensions

Classification of function objects

21: STL Algorithms

Function objects

Automatic creation of function objects

Binders

Function pointer adapters

SGI extensions

A catalog of STL algorithms

Support tools for example creation

Manipulating sequences

Sorting and operations on sorted ranges

Searching & replacing

Sorting

Locating elements in sorted ranges

Merging sorted ranges

Set operations on sorted ranges

Applying an operation to each element in a range

Heap operations

Creating your own STL-style algorithms

The "most derived" class and virtual base initialization

Part 3: Advanced Topics

22: Multiple inheritance

"Tying off" virtual bases with a default constructor

Repairing an interface

Termination vs. resumption

23: Exception handling

Error handling in C

Throwing an exception

Catching an exception

The try block

Exception handlers

The exception specification

unexpected( )

set_unexpected( )

Better exception specifications?

Catching any exception

Rethrowing an exception

Uncaught exceptions

terminate( )

set_terminate( )

Function-level try blocks

Cleaning up

Constructors

Making everything an object

Exception matching

Standard exceptions

Programming with exceptions

When to avoid exceptions

Not for asynchronous events

Not for ordinary error conditions

Not for flow-of-control

You’re not forced to use exceptions

New exceptions, old code

Typical uses of exceptions

Always use exception specifications

Start with standard exceptions

Nest your own exceptions

Use exception hierarchies

Multiple inheritance

Catch by reference, not by value

Throw exceptions in constructors

Don’t cause exceptions in destructors

24: Run-time type identification

The “Shape” example

What is RTTI?

Two syntaxes for RTTI

Syntax specifics

typeid( ) with built-in types

Producing the proper type name

Nonpolymorphic types

Casting to intermediate levels

void pointers

Using RTTI with templates

References

Exceptions

Multiple inheritance

Sensible uses for RTTI

Revisiting the trash recycler

Mechanism & overhead of RTTI

Creating your own RTTI

XX: Maintaining system integrity

The canonical object form

An extended canonical form

Dynamic aggregation

Reference counting

Reference-counted class hierarchies

Features, idioms, patterns

25: Design patterns

The pattern concept

The singleton

Variations on singleton

Classifying patterns

Basic complexity hiding

Factories: encapsulating object creation

Polymorphic factories

Abstract factories

Virtual constructorsBE

The “interface” idiom

The “inner class” idiom

The observer example

Multiple dispatching

Visitor, a type of multiple dispatching

Efficiency

Flyweight

The composite

Evolving a design: the trash recycler

Improving the design

“Make more objects”

A pattern for prototyping creation

Trash subclasses

Parsing Trash from an external file

Recycling with prototyping

Abstracting usage

Applying double dispatching

Implementing the double dispatch

Applying the visitor pattern

More coupling?

RTTI considered harmful?

Abstract base class for debugging

26: Tools & topics

Tracking new/delete & malloc/free

CGI programming in C++

Encoding data for CGI

The CGI parser

Testing the CGI parser

Using POST

Handling mailing lists

Maintaining your list

Mailing to your list

A general information-extraction CGI program

Parsing the data files