"Thinking in C++"

Free C++ ebook download. This site provides online information about engineering book/ebook and software collected from public domain or url provided by author with some free license.

Table of Contents "Thinking in C++":

VOL 1
1: Introduction to Objects

The progress of abstraction
An object has an interface
The hidden implementation
Reusing the implementation
Inheritance: reusing the interface
Interchangeable objects with polymorphism
Creating and destroying objects
Exception handling: dealing with errors
Analysis and design
Extreme programming
Why C++ succeeds
-A better C
-You’re already on the learning curve
-Efficiency
-Systems are easier to express and understand
-Maximal leverage with libraries
-Source-code reuse with templates
-Error handling
-Programming in the large
Strategies for transition

2: Making & Using Objects

The process of language translation
Tools for separate compilation
Declarations vs. definitions
Linking
Using libraries
Your first C++ program
More about iostreams
Introducing strings
Reading and writing files
Introducing vector

3: The C in C++

Creating functions
Controlling execution
Introduction to operators
Introduction to data types
Scoping
Specifying storage allocation
Operators and their use
Composite type creation
Debugging hints
Function addresses
Make: managing separate compilation

4: Data Abstraction

A tiny C-like library
What’s wrong?
The basic object
What’s an object?
Abstract data typing
Object details
Header file etiquette
Nested structures

5: Hiding the Implementation

Setting limits
C++ access control
Friends
Object layout
The class
Handle classes

6: Initialization & Cleanup

Guaranteed initialization with the constructor
Guaranteed cleanup with the destructor
Elimination of the definition block
Stash with constructors and destructors
Stack with constructors & destructors
Aggregate initialization
Default constructors

7: Function Overloading & Default Arguments

More name decoration
Overloading example
Default arguments
Choosing overloading vs. default arguments

8: Constants

Value substitution
Pointers
Function arguments & return values
Classes
volatile

9: Inline Functions

Preprocessor pitfalls
Inline functions
Stash & Stack with inlines
Inlines & the compiler
Reducing clutter
More preprocessor features
Improved error checking

10: Name Control

Static elements from C
Namespaces
Static members in C++
Static initialization dependency
Alternate linkage specifications

11: References & the Copy-Constructor

Pointers in C++
References in C++
The copy-constructor
Pointers to members

12: Operator Overloading

Warning & reassurance
Syntax
Overloadable operators
Non-member operators
Overloading assignment
Automatic type conversion

13: Dynamic Object Creation

Object creation
Early examples redesigned
Running out of storage
Overloading new & delete

14: Inheritance & Composition

Composition syntax
Inheritance syntax
The constructor initializer list
Combining composition & inheritance
Order of constructor & destructor calls
Name hiding
Functions that don’t automatically inherit
Choosing composition vs. inheritance
Operator overloading & inheritance
Multiple inheritance
Incremental development
Upcasting

15: Polymorphism & Virtual Functions

Evolution of C++ programmers
Upcasting
The problem
virtual functions
How C++ implements late binding
Why virtual functions?
Abstract base classes and pure virtual functions
Inheritance and the VTABLE
Overloading & overriding
virtual functions & constructors
Destructors and virtual destructors
Operator overloading
Downcasting

16: Introduction to Templates

Containers
Overview of templates
Template syntax
Stack and Stash as templates
Turning ownership on and off
Holding objects by value
Introducing iterators
Why iterators?

A: Coding Style
B: Programming Guidelines
C: Recommended Reading

VOL 2

Introduction
Part 1: Building Stable Systems
1: Exception handling
2: Defensive programming
Part 2: The Standard C++ Library
3: Strings in depth
4: Iostreams
5: Templates in depth
6: Generic algorithms
7: Generic containers
Part 3: Special Topics
8: Runtime type identification
9: Multiple inheritance
10: Design patterns
11: Concurrency
Appendix
A: Recommended reading
B: Etc

Download volume 1.
Download volume 2.