You are previewing C++ Common Knowledge: Essential Intermediate Programming.
O'Reilly logo
C++ Common Knowledge: Essential Intermediate Programming

Book Description

“We live in a time when, perhaps surprisingly, the best printed works on C++ are just now emerging. This is one of those works. Although C++ has been at the forefront of innovation and productivity in software development for more than two decades, it is only now being fully understood and utilized. This book is one of those rare contributions that can bear repeated study by practitioners and experts alike. It is not a treatise on the arcane or academic—rather it completes your understanding of things you think you know but will bite you sooner or later until you really learn them. Few people have mastered C++ and software design as well as Steve has; almost no one has such a level head as he when it comes to software development. He knows what you need to know, believe me. When he speaks, I always listen—closely. I invite you to do the same. You (and your customers) will be glad you did.”

—Chuck Allison, editor, The C++ Source

“Steve taught me C++. This was back in 1982 or 1983, I think—he had just returned from an internship sitting with Bjarne Stroustrup inventor of C++ at Bell Labs. Steve is one of the unsung heroes of the early days, and anything Steve writes is on my A-list of things to read. This book is an easy read and collects a great deal of Steve’s extensive knowledge and experience. It is highly recommended.”

—Stan Lippman, coauthor of C++ Primer, Fourth Edition

“I welcome the self-consciously non-Dummies approach of a short, smart book.”

—Matthew P. Johnson, Columbia University

“I agree with the author’s assessment of the types of programmers. I have encountered the same types in my experience as a developer and a book like this will go far to help bridge their knowledge gap.... I think this book complements other books, like Effective C++ by Scott Meyers. It presents everything in a concise and easy-to-read style.”

—Moataz Kamel, senior software designer, Motorola Canada

“Dewhurst has written yet another very good book. This book should be required reading for people who are using C++ (and think that they already know everything in C++).”

—Clovis Tondo, coauthor of C++ Primer Answer Book

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

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