Preface xi
Acknowledgments xvii
A Note on Typographical Conventions xix
Item 1:Data Abstraction 1
Item 2:Polymorphism 3
Item 3:Design Patterns 7
Item 4:The Standard Template Library 11
Item 5:References Are Aliases, Not Pointers 13
Item 6:Array Formal Arguments 17
Item 7:Const Pointers and Pointers to Const 21
Item 8:Pointers to Pointers 25
Item 9:New Cast Operators 29
Item 10:Meaning of a Const Member Function 33
Item 11:The Compiler Puts Stuff in Classes 37
Item 12:Assignment and Initialization Are Different 41
Item 13:Copy Operations 45
Item 14:Function Pointers 49
Item 15:Pointers to Class Members Are Not Pointers 53
Item 16:Pointers to Member Functions Are Not Pointers 57
Item 17:Dealing with Function and Array Declarators 61
Item 18:Function Objects 63
Item 19:Commands and Hollywood 67
Item 20:STL Function Objects 71
Item 21:Overloading and Overriding Are Different 75
Item 22:Template Method 77
Item 23:Namespaces 81
Item 24:Member Function Lookup 87
Item 25:Argument Dependent Lookup 89
Item 26:Operator Function Lookup 91
Item 27:Capability Queries 93
Item 28:Meaning of Pointer Comparison 97
Item 29:Virtual Constructors and Prototype 99
Item 30:Factory Method 103
Item 31:Covariant Return Types 107
Item 32:Preventing Copying 111
Item 33:Manufacturing Abstract Bases 113
Item 34:Restricting Heap Allocation 117
Item 35:Placement New 119
Item 36:Class-Specific Memory Management 123
Item 37:Array Allocation 127
Item 38:Exception Safety Axioms 131
Item 39:Exception Safe Functions 135
Item 40:RAII 139
Item 41:New, Constructors, and Exceptions 143
Item 42:Smart Pointers 145
Item 43:auto_ptr Is Unusual 147
Item 44:Pointer Arithmetic 149
Item 45:Template Terminology 153
Item 46:Class Template Explicit Specialization 155
Item 47:Template Partial Specialization 161
Item 48:Class Template Member Specialization 165
Item 49:Disambiguating with Typename 169
Item 50:Member Templates 173
Item 51:Disambiguating with Template 179
Item 52:Specializing for Type Information 183
Item 53:Embedded Type Information 189
Item 54:Traits 193
Item 55:Template Template Parameters 199
Item 56:Policies 205
Item 57:Template Argument Deduction 209
Item 58:Overloading Function Templates 213
Item 59:SFINAE 217
Item 60:Generic Algorithms 221
Item 61:You Instantiate What You Use 225
Item 62:Include Guards 229
Item 63:Optional Keywords 231
Bibliography 235
Index 237
Index of Code Examples 245
0321321928T02022005
Most C++ programmers are not experts, and they often need preliminaryeducation in various C++ language features, coding techniques, and designpatterns before they can be fully productive. Programmers who need thiseducation include: (1) domain experts who are C programmers, but have onlybasic knowledge of C++; (2) new hires who may have an excellent appreciationof C++ from college courses, but have no practical experience; (3) expert Javaprogrammers who tend to program in C++ the way they do in Java; (4) C++programmers with years of experience maintaining programs, but noknowledge beyond the basics required for that task. What they're missing is thecommon knowledge among experienced C++ programmers, what it takes towrite production-quality programs. That common knowledge is the topic ofthis book.
Stephen C. Dewhurst was among the first users of C++ at Bell Labs.
He has more than twenty years of experience in applying C++ to
problem areas such as compiler design, securities trading,
e-commerce, and embedded telecommunications. He is the author and
coauthor of several books on C++ and is a member of the advisory
board for The C++ Source, a contributing editor for C/C++ Users
Journal, and a former columnist for C++ Report. He is also the
author of two C++ compilers and numerous articles on compiler
design and C++ programming techniques.
0321321928AB02022005
|
Ask a Question About this Product More... |
|
