Review

The book is aimed at experienced C++ developers who want a guide to enhance their design and programming proficiency. The book provides facts and techniques and provides a knowledge base for advanced, Standard compliant and efficient use of C++. The book also explains the philosophy behind the design and evolution of C++.

Because of it's target audience, the book focuses on the core issues and does not explain the language from the basics; the book does not cover fundamental types, or what variables, pointers, structs and functions are.

The book is easy to read and includes code example for the concepts discussed. Code soft-copies can be obtained from the publisher's web-site for the book.

The author was involved in the standarisation of C++ and provides information on why ANSI C++ contains or excludes certain features. This extends to a whole chapter (Chap. 14) on what was dropped from the standard and what the standard might eventually include. This chapter adds very little useful information.

The book includes useful information in chapters 11 and 12 and appendix A, however the professional/experienced C++ or Object Oriented programmer may be better off with The C++ Programming Language, Special Edition by Bjarne Stroustrup, rather than this book.
4 Sep 2001

Brief Description of Contents

Part 1.

What's New in C++

Chap. 1.

Introduction

Contains an introduction to,

The origins of C++
ANSI Committee Established
C++ as Opposed to Other Object-Oriented Languages
Aim of the Book
Target Audience
Organisation of the Book

Chap. 2.

Standard Briefing: The Latest Addenda to ANSI/ISO C++

Introduction
The Standard's Terminology
Addenda
Deprecated Feature
Conclusions

Part 2.

OO Design and Programming

Chap. 3

Operating Overloading

Operator Overloading Rules of Thumb
Restrictions on Operator Overloading
Conversion Operators
Postfix and Prefix Operators
Using Function Call Syntax
Consistent Operator Overloading
Returning Objects by Value
Multiple Overloading
Overloading Operators for Other User-Defined Types
Overloading the Subscript Operator
Function Objects
Conclusions

Chap. 4.

Special Member Functions: Default Constructor, Copy Constructor, Destructor and Assignment Operator

Constructors
Copy Constructor
Simulating Virtual Constructors
Assignment Operator
When are User-Written Copy Constructors and Assignment Operators Needed?
Implementing Copy Constructor and Assignment Operator
Blocking Object Copying
Destructors
Constructors and Destructors Should Be Minimal
Conclusions

Chap. 5.

Object-Oriented Programming and Design

Programming Paradigms
Techniques Of Object-Oriented Programming
Designing Class Hierarchies
Conclusions

Part 3.

Facilities for Extensible and Robust Design

Chap 6.

Exception Handling

Introduction
Traditional Error Handling Methods
Enter Exception Handling
Applying Exception Handling
Exceptions During Object's Construction and Destruction
Global Objects: Construction and Destruction
Advanced Exception Handling Techniques
Exception Handling Performance Overhead
Misuses of Exception Handling
Conclusions

Chap. 7.

RunTime Type Information

Structure of This Chapter
Making Do Without RTTI
RTTI Constituents
The Cost of Runtime Type Information
Conclusions

Chap 8.

`Namespace`s

Introduction
The Rationale Behind Namespaces
A Brief Historical Background
Properties of Namespaces
Namespaces Utilization Policy in Large-Scale Projects
Namespaces and Version Control
The Interaction of Namespaces with Other Language Features
Restrictions on Namespaces
Conclusions

Part 4.

Templates and Generic Programming

Chap. 9.

Templates

Introduction
Class Templates
Function Templates
Performance Considerations
Interaction with Other Languages
Conclusions

Chap. 10.

STL and Generic Programming

Generic Programming
Organisation of STL Header Files
Containers
Iterators
Algorithms
Function Objects
Adaptors
Allocators
Specialized Containers,
Associative Containers
Class auto_ptr
Nearly Containers
Class string
Conclusions

Part 5.

Under The Hood

Chap. 11.

Memory Management

Introduction
Types of Storage
POD (Plain Old Data) and Non-POD Objects
The Lifetime of a POD Object
The Lifetime of a Non-POD Object
Allocation and Deallocation Functions
malloc() and free() Verses new and delete
new and delete
Exceptions During Object Construction
Alignment Considerations
Overloading new and delete in a Class
Guidelines for Effective Memory Usage
Explicit Initializations of POD Objective
Data Pointers Verses Function Pointers
Pointer Equality
Storage Reallocation
Static Local Variables
Global Anonymous Unions
The const and volatile Properties of an Object
Conclusions

Chap. 12.

Optimizing Your Code

Introduction
Before Optimizing Your Software
Declaration Placement
Inline Functions
Optimization Memory Usage
Speed Optimisations
A Last Resort
Conclusions

Chap. 13.

C Language Compatibility Issues

Differences Between ISO C and the C Subset of ANSI/ISO C++
Quiet Differences Between C and C++
Migrating from C to C++
Designing Legacy Code Wrapper Classes
Multilingual Environments
C and C++ Linkage Conventions
Minimize the Interface Between C and C++ Code
Mixing <iostream> Classes with <stdio.h> Functions
Accessing a C++ Object in C Code
Conclusions

Chap.14.

Concluding Remarks and Future Directions

Introduction
Some of the Features That Almost Made It into the Standard
The Evolution of C++ Compared to Other Languages
Possible Future Additions to C++
Conclusions

Appendices

Manual of Programming Style

Introduction
Coding Conventions
Design by Contract
Avoid Function-Like Macros and Macro Constants
Be Cautious with Unsigned Integers
Prefer References to Pointers
Use typedef Judiciously
Place a default label in every switch statement
Avoid Using Double Underscore in Identifiers
Avoid Using Deprecated Features
Use New Cast Operators Instead of C-style Cast
Remember to Update Comments when the Code is Changed
Use Numerous Access Specifiers When It Can Improve Readability
Use #include Guards
Infrastructure Components Should Trust Their Users
Use Type Affixes in Hard Coded Literals
When to Use a Pure Virtual Member Function
Avoid Improper Inheritance
Conclusions

C++ Keywords

Back