|
|
The ANSI/ISO C++ Professional Programmer's Handbook
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 fundermental types, or what variables, pointers, structs and functions are.
The book is easy to read and includes code example for the concepts discussed. Code softcopies 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 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.
Back
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 Lanaguages,
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. | Namespaces
Introduction,
The Rationale Behind Namespaces,
A Brief Historical Background,
Properties of Namespaces,
Namespace Utilization Policy in Large-Scale Projects,
Namespaces and Version Control,
The Interaction of Namespaces with Other Language Features,
Restrictions on Namespaces,
Conclusions. |
| Part 3. | 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,
The Size of a Complete Object Can Never Be Zero,
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 |
| A | Manual of Programming Style
Introduction,
Coding Conventions,
Design by Contract,
Avoid Function-Like Macros and Macro Constants,
Be Cautious with Unsigned Integers,
Prefer Referances 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. |
| B | C++ Keywords |
Back
|
