FREE Servers/Workstations Resources from Intel:
Whitepaper: Itanium 2-based Solutions and x86 Architecture	Whitepaper: Which Is Right for You--Itanium 2 or x86 Architecture?	Whitepaper: Air-Cooled High-Performance Data Centers: Case Studies and Best Methods

Bruce Eckel's Thinking in C++, 2nd Ed

Contents | Prev | Next

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

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

Thinking in C++ 2nd edition VERSION TICA18

Coding standards

Language standards

Language support

Seminars & CD Roms

Acknowledgements

1: Introduction to objects

The progress of abstraction

An object has an interface

The hidden implementation

Reusing the implementation

Inheritance: reusing the interface

Is-a vs. is-like-a relationships

Interchangeable objects with polymorphism

Creating and destroying objects

Exception handling: dealing with errors

Analysis and design

Phase 0: Make a plan

The mission statement

Phase 1: What are we making?

Phase 2: How will we build it?

Five stages of object design

Guidelines for object development

Phase 3: Build it

Phase 4: Iteration

Why C++ succeeds

You’re already on the learning curve

Systems are easier to express and understand

Maximal leverage with libraries

Source-code reuse with templates

Programming in the large

Strategies for transition

2. Low-risk project

3. Model from success

4. Use existing class libraries

5. Don’t rewrite existing code in C++

Management obstacles

Performance issues

Common design errors

2: Making & using objects

The process of language translation

The compilation process

Static type checking

Tools for separate compilation

Declarations vs. definitions

Function declaration syntax

Function definitions

Variable declaration syntax

Including headers

Standard C++ include format

Using libraries

How the linker searches a library

Secret additions

Using plain C libraries

Your first C++ program

Using the iostreams class

Fundamentals of program structure

"Hello, world!"

Running the compiler

More about iostreams

Character array concatenation

Simple file manipulation

Introducing strings

Reading and writing files

Introducing vector

3: The C in C++

Creating functions

Function return values

Using the C function library

Creating your own libraries with the librarian

Controlling execution

The break and continue Keywords

Introduction to operators

Auto increment and decrement

Introduction to data types

Basic built-in types

bool, true, & false

Introduction to Pointers

Modifying the outside object

Introduction to C++ references

Pointers and references as modifiers

Defining variables on the fly

Specifying storage allocation

Global variables

Local variables

Register variables

Constant values

Operators and their use

Mathematical operators

Introduction to preprocessor macros

Relational operators

Logical operators

Bitwise operators

Shift operators

Unary operators

The ternary operator

The comma operator

Common pitfalls when using operators

Casting operators

sizeof – an operator by itself

The asm keyword

Explicit operators

Composite type creation

Aliasing names with typedef

Combining variables with struct

Pointers and structs

Clarifying programs with enum

Type checking for enumerations

Saving memory with union

Pointers and arrays

Pointer arithmetic

Debugging hints

Debugging flags

Preprocessor debugging flags

Runtime debugging flags

Turning variables and expressions into strings

The C assert( ) macro

Make: an essential tool for separate compilation

Make activities

Default targets

Makefiles in this book

An example makefile

4: Data abstraction

A tiny C-like library

Dynamic storage allocation

The basic object

What's an object?

Abstract data typing

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

5: Hiding the implementation

C++ access control

Modifying Stash to use access control

Modifying Stack to use access control

Hiding the implementation

Reducing recompilation

6: Initialization & cleanup

Guaranteed initialization with the constructor

Guaranteed cleanup with the destructor

Elimination of the definition block

Storage allocation

Stash with constructors and destructors

Stack with constructors & destructors

Aggregate initialization

Default constructors

7: Function overloading & default arguments

More name decoration

Overloading on return values

Type-safe linkage

Overloading example

Default arguments

Placeholder arguments

Choosing overloading vs. default arguments

8: Constants

Value substitution

const in header files

Differences with C

Pointer to const

Assignment and type checking

Character array literals

Function arguments & return values

Passing by const value

Returning by const value

Passing and returning addresses

Standard argument passing

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

Order of evaluation

Hidden activities in constructors & destructors

Forward referencing

Reducing clutter

More preprocessor features

Improved error checking

10: Name control

Static elements from C

static variables inside functions

static class objects inside functions

Static object destructors

Controlling linkage

Other storage class specifiers

Creating a namespace

Unnamed namespaces

Using a namespace

Scope resolution

The using directive

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

Alternate linkage specifications

11: ReferencesBE & the copy-constructor

Pointers in C++

References in C++

References in functions

const references

Pointer references

Argument-passing guidelines

The copy-constructor

Passing & returning by value

Passing & returning large objects

Function-call stack frame

Bitcopy versus initialization

Copy-construction

Temporary objects

Default copy-constructor

Alternatives to copy-construction

Preventing pass-by-value

Functions that modify outside objects

Pointers to members

12: BEOperator overloading

Warning & reassurance

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

A perfect example: strings

Pitfalls in automatic type conversion

Hidden activities

13: Dynamic object creation

Object creation

C’s approach to the heap

operator delete

A simple example

Memory manager overhead

Early examples redesigned

Stash for pointers

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

Constructor calls

Object placement

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

Functions that don’t automatically inherit

Choosing composition vs. inheritance

private inheritance

Publicizing privately inherited members

protected inheritance

Multiple inheritance

Incremental development

Why “upcasting”?

Upcasting and the copy-constructor (not indexed)

Composition vs. inheritance (revisited)

Pointer & reference upcasting

15: Polymorphism & virtual functions

Evolution of C++ programmers

Function call binding

virtual functions

How C++ implements late binding

Storing type information

Picturing virtual functions

Installing the vpointer

Objects are different

Why virtual functions?

Abstract base classes and pure virtual functions

Pure virtual definitions

Inheritance and the VTABLE

virtual functions & constructors

Order of constructor calls

Behavior of virtual functions inside constructors

Destructors and virtual destructors

Virtuals in destructors

16: Introduction to templates

Containers & iterators

The need for containers

Overview of templates

The Smalltalk approach

The template approach

Template syntax

Non-inline function definitions

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

A string application

18: Iostreams

Iostreams to the rescue

Sneak preview of operator overloading

Inserters and extractors

Line-oriented input

Overloaded versions of get( )

Reading raw bytes

Iostream buffering

Using get( ) with a streambuf

Seeking in iostreams

Creating read/write files

User-allocated storage

Output strstreams

Automatic storage allocation

Proving movement

Output stream formatting

Internal formatting data

Width, fill and precision

An exhaustive example

Formatting manipulators

Manipulators with arguments

Creating manipulators

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

19: Templates in depth

Nontype template arguments

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”

20: STL Containers & Iterators

Containers and iterators

STL reference documentation

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

Cost of overflowing allocated storage

Inserting and erasing elements

Converting between sequences

Cost of overflowing allocated storage

Checked random-access

Special list operations

Swapping all basic sequences

Robustness of lists

Performance comparison

Eliminating strtok( )

StreamTokenizer: a more flexible solution

A completely reusable tokenizer

Priority queues

Associative containers

Generators and fillers for associative containers

The magic of maps

A command-line argument tool

Multimaps and duplicate keys

Combining STL containers

Cleaning up containers of pointers

Creating your own containers

Freely-available STL extensions

21: STL Algorithms

Function objects

Classification of function objects

Automatic creation of function objects

Function pointer adapters

A catalog of STL algorithms

Support tools for example creation

Filling & generating

Manipulating sequences

Searching & replacing

Comparing ranges

Removing elements

Sorting and operations on sorted ranges

Locating elements in sorted ranges

Merging sorted ranges

Set operations on sorted ranges

Heap operations

Applying an operation to each element in a range

Numeric algorithms

General utilities

Creating your own STL-style algorithms

Part 3: Advanced Topics

22: Multiple inheritance

Duplicate subobjects

Ambiguous upcasting

virtual base classes

The "most derived" class and virtual base initialization

"Tying off" virtual bases with a default constructor

MI-based persistence

Improved persistence

Repairing an interface

23: Exception handling

Error handling in C

Throwing an exception

Catching an exception

Exception handlers

Termination vs. resumption

The exception specification

set_unexpected( )

Better exception specifications?

Catching any exception

Rethrowing an exception

Uncaught exceptions

set_terminate( )

Function-level try blocks

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

Avoid naked pointers

24: Run-time type identification

The “Shape” example

Two syntaxes for RTTI

Syntax specifics

typeid( ) with built-in types

Producing the proper type name

Nonpolymorphic types

Casting to intermediate levels

Using RTTI with templates

Multiple inheritance

Sensible uses for RTTI

Revisiting the trash recycler

Mechanism & overhead of RTTI

Creating your own RTTI

Explicit cast syntax

reinterpret_cast

XX: Maintaining system integrity

The canonical object form

An extended canonical form

Dynamic aggregation

Reference counting

Reference-counted class hierarchies

25: Design patterns

The pattern concept

Variations on singleton

Classifying patterns

Features, idioms, patterns

Basic complexity hiding

Factories: encapsulating object creation

Polymorphic factories

Abstract factories

Virtual constructorsBE

Destructor operation

Functor/Command

The “interface” idiom

The “inner class” idiom

The observer example

Multiple dispatching

Visitor, a type of multiple dispatching

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

RTTI considered harmful?

26: Tools & topics

The code extractor

Abstract base class for debugging

Tracking new/delete & malloc/free

CGI programming in C++

Encoding data for CGI

Testing the CGI parser

Handling mailing lists

Maintaining your list

Mailing to your list

A general information-extraction CGI program

Parsing the data files

A: Coding style

Begin and end comment tags

Parens, braces and indentation

Order of header inclusion

Include guards on header files

Use of namespaces

Use of require( ) and assure( )

B: Programming guidelines

C: Recommended reading

My own list of books

Depth & dark corners

Analysis & Design

Design Patterns

D:Compiler specifics

Contents | Prev | Next