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 : zi
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 : zi
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
No comments:
Post a Comment