C++ Common Knowledge: Essential Intermediate Programming
By Stephen C. Dewhurst
   
Publisher : Addison Wesley Professional
Pub Date : February 28, 2005
ISBN : 0-321-32192-8
Pages : 272
Slots : 1.0   



What Every Professional C++ Programmer Needs to Know—Pared to Its Essentials So It Can Be Efficiently and Accurately Absorbed

C++ is a large, complex language, and learning it is never entirely easy. But some concepts and techniques must be thoroughly mastered if programmers are ever to do professional-quality work. This book cuts through the technical details to reveal what is commonly understood to be absolutely essential. In one slim volume, Steve Dewhurst distills what he and other experienced managers, trainers, and authors have found to be the most critical knowledge required for successful C++ programming. It doesn't matter where or when you first learned C++. Before you take another step, use this book as your guide to make sure you've got it right!

This book is for you if

You're no "dummy," and you need to get quickly up to speed in intermediate to advanced C++

You've had some experience in C++ programming, but reading intermediate and advanced C++ books is slow-going

You've had an introductory C++ course, but you've found that you still can't follow your colleagues when they're describing their C++ designs and code

You're an experienced C or Java programmer, but you don't yet have the experience to develop nuanced C++ code and designs

You're a C++ expert, and you're looking for an alternative to answering the same questions from your less-experienced colleagues over and over again

C++ Common Knowledge covers essential but commonly misunderstood topics in C++ programming and design while filtering out needless complexity in the discussion of each topic. What remains is a clear distillation of the essentials required for production C++ programming, presented in the author's trademark incisive, engaging style.

Table of Contents
     Copyright
     Praise for C++ Common Knowledge
     Preface
     Acknowledgments
     A Note on Typographical Conventions
       Item 1.  Data Abstraction
       Item 2.  Polymorphism
       Item 3.  Design Patterns
       Item 4.  The Standard Template Library
       Item 5.  References Are Aliases, Not Pointers
       Item 6.  Array Formal Arguments
       Item 7.  Const Pointers and Pointers to Const
       Item 8.  Pointers to Pointers
       Item 9.  New Cast Operators
       Item 10.  Meaning of a Const Member Function
       Item 11.  The Compiler Puts Stuff in Classes
       Item 12.  Assignment and Initialization Are Different
       Item 13.  Copy Operations
       Item 14.  Function Pointers
       Item 15.  Pointers to Class Members Are Not Pointers
       Item 16.  Pointers to Member Functions Are Not Pointers
       Item 17.  Dealing with Function and Array Declarators
       Item 18.  Function Objects
       Item 19.  Commands and Hollywood
       Item 20.  STL Function Objects
       Item 21.  Overloading and Overriding Are Different
       Item 22.  Template Method
       Item 23.  Namespaces
       Item 24.  Member Function Lookup
       Item 25.  Argument Dependent Lookup
       Item 26.  Operator Function Lookup
       Item 27.  Capability Queries
       Item 28.  Meaning of Pointer Comparison
       Item 29.  Virtual Constructors and Prototype
       Item 30.  Factory Method
       Item 31.  Covariant Return Types
       Item 32.  Preventing Copying
       Item 33.  Manufacturing Abstract Bases
       Item 34.  Restricting Heap Allocation
       Item 35.  Placement New
       Item 36.  Class-Specific Memory Management
       Item 37.  Array Allocation
       Item 38.  Exception Safety Axioms
        Axiom 1: Exceptions Are Synchronous
        Axiom 2: It's Safe to Destroy
        Axiom 3: Swap Doesn't Throw
       Item 39.  Exception Safe Functions
       Item 40.  RAII
       Item 41.  New, Constructors, and Exceptions
       Item 42.  Smart Pointers
       Item 43.  auto_ptr Is Unusual
       Item 44.  Pointer Arithmetic
       Item 45.  Template Terminology
       Item 46.  Class Template Explicit Specialization
       Item 47.  Template Partial Specialization
       Item 48.  Class Template Member Specialization
       Item 49.  Disambiguating with Typename
       Item 50.  Member Templates
       Item 51.  Disambiguating with Template
       Item 52.  Specializing for Type Information
       Item 53.  Embedded Type Information
       Item 54.  Traits
       Item 55.  Template Template Parameters
       Item 56.  Policies
       Item 57.  Template Argument Deduction
       Item 58.  Overloading Function Templates
       Item 59.  SFINAE
       Item 60.  Generic Algorithms
       Item 61.  You Instantiate What You Use
       Item 62.  Include Guards
       Item 63.  Optional Keywords
     Bibliography
     Index
     Index of Code Examples

不是三个都一样，是三个分包，要是三个没下全是解压不了的