O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

The Design and Evolution of C++, First Edition

Book Description

The inventor of C++ presents the definitive insider's guide to the design and development of the C++ programming language. Without ommitting critical details or getting bogged down in technicalities, Stroustrup presents his unique insights into the decisions that shaped C++. Every C++ programmer will benefit from Stroustrup's explanations of the 'why's' behind C++ from the earliest features, such as the original class concept, to the latest extensions, such as new casts and explicit template instantiation.

Some C++ design decisions have been universally praised, while others remain controversial, and debated vigorously; still other features have been rejected based on experimentation. In this book, Stroustrup dissects many of these decisions to present a case study in "real object- oriented language development" for the working programmer. In doing so, he presents his views on programming and design in a concrete and useful way that makes this book a must-buy for every C++ programmer.

Features

  • Written by the inventor of C++ Stroustrup
  • Provides insights into the design decisions which shaped C++.
  • Gives technical summaries of C++.
  • Discusses the latest language features: templates, exceptions, run-time type information, and namespaces.
  • Presents Stroustrup's unique programming and design views.


0201543303B04062001

Table of Contents

  1. Cover Page
  2. About This eBook
  3. Title Page
  4. Copyright Page
  5. Preface
    1. Acknowledgments
  6. Contents
  7. 0. Notes to the Reader
    1. Introduction
    2. How to Read this Book
    3. C++ Timeline
    4. Focus on Use and Users
    5. Programming Languages
    6. References
  8. Part I
    1. 1. The Prehistory of C++
      1. 1.1 Simula and Distributed Systems
      2. 1.2 C and Systems Programming
      3. 1.3 General Background
    2. 2. C with Classes
      1. 2.1 The Birth of C with Classes
      2. 2.2 Feature overview
      3. 2.3 Classes
      4. 2.4 Run-Time Efficiency
      5. 2.5 The Linkage Model
      6. 2.6 Static Type Checking
      7. 2.7 Why C?
      8. 2.8 Syntax Problems
      9. 2.9 Derived Classes
      10. 2.10 The Protection Model
      11. 2.11 Run-Time Guarantees
      12. 2.12 Minor Features
      13. 2.13 Features Considered, but not Provided
      14. 2.14 Work Environment
    3. 3. The Birth of C++
      1. 3.1 From C with Classes to C++
      2. 3.2 Aims
      3. 3.3 Cfront
      4. 3.4 Language Features
      5. 3.5 Virtual Functions
      6. 3.6 Overloading
      7. 3.7 References
      8. 3.8 Constants
      9. 3.9 Memory Management
      10. 3.10 Type Checking
      11. 3.11 Minor Features
      12. 3.12 Relationship to Classic C
      13. 3.13 Tools for Language Design
      14. 3.14 The C++ Programming Language (1st edition)
      15. 3.15 The Whatis? Paper
    4. 4. C++ Language Design Rules
      1. 4.1 Rules and Principles
      2. 4.2 General Rules
      3. 4.3 Design Support Rules
      4. 4.4 Language-Technical Rules
      5. 4.5 Low-Level Programming Support Rules
      6. 4.6 A Final Word
    5. 5. Chronology 1985-1993
      1. 5.1 Introduction
      2. 5.2 Release 2.0
      3. 5.3 The Annotated Reference Manual
      4. 5.4 ANSI and ISO Standardization
    6. 6. Standardization
      1. 6.1 What is a Standard?
      2. 6.2 How does the Committee Operate?
      3. 6.3 Clarifications
      4. 6.4 Extensions
      5. 6.5 Examples of Proposed Extensions
    7. 7. Interest and Use
      1. 7.1 The Explosion in Interest and Use
      2. 7.2 Teaching and Learning C++
      3. 7.3 Users and Applications
      4. 7.4 Commercial Competition
    8. 8. Libraries
      1. 8.1 Introduction
      2. 8.2 C++ Library Design
      3. 8.3 Early Libraries
      4. 8.4 Other Libraries
      5. 8.5 A Standard Library
    9. 9. Looking Ahead
      1. 9.1 Introduction
      2. 9.2 Retrospective
      3. 9.3 Only a Bridge?
      4. 9.4 What Will Make C++ Much More Effective?
  9. Part II
    1. 10. Memory Management
      1. 10.1 Introduction
      2. 10.2 Separating Allocation and Initialization
      3. 10.3 Array Allocation
      4. 10.4 Placement
      5. 10.5 Deallocation Problems
      6. 10.6 Memory Exhaustion
      7. 10.7 Automatic Garbage Collection
    2. 11. Overloading
      1. 11.1 Introduction
      2. 11.2 Overload Resolution
      3. 11.3 Type-Safe Linkage
      4. 11.4 Object Creation and Copying
      5. 11.5 Notational Convenience
      6. 11.6 Adding Operators to C++
      7. 11.7 Enumerations
    3. 12. Multiple Inheritance
      1. 12.1 Introduction
      2. 12.2 Ordinary Base Classes
      3. 12.3 Virtual Base Classes
      4. 12.4 The Object Layout Model
      5. 12.5 Method Combination
      6. 12.6 The Multiple Inheritance Controversy
      7. 12.7 Delegation
      8. 12.8 Renaming
      9. 12.9 Base and Member Initializers
    4. 13. Class Concept Refinements
      1. 13.1 Introduction
      2. 13.2 Abstract Classes
      3. 13.3 const Member Functions
      4. 13.4 Static Member Functions
      5. 13.5 Nested Classes
      6. 13.6 Inherited::
      7. 13.7 Relaxation of Overriding Rules
      8. 13.8 Multi-methods
      9. 13.9 Protected Members
      10. 13.10 Improved Code Generation
      11. 13.11 Pointers to Members
    5. 14. Casting
      1. 14.1 Major Extensions
      2. 14.2 Run-Time Type Information
      3. 14.3 A New Cast Notation
    6. 15. Templates
      1. 15.1 Introduction
      2. 15.2 Templates
      3. 15.3 Class Templates
      4. 15.4 Constraints on Template Arguments
      5. 15.5 Avoiding Code Replication
      6. 15.6 Function Templates
      7. 15.7 Syntax
      8. 15.8 Composition Techniques
      9. 15.9 Template Class Relationships
      10. 15.10 Template Instantiation
      11. 15.11 Implications of Templates
    7. 16. Exception Handling
      1. 16.1 Introduction
      2. 16.2 Aims and Assumptions
      3. 16.3 Syntax
      4. 16.4 Grouping
      5. 16.5 Resource Management
      6. 16.6 Resumption vs. Termination
      7. 16.7 Asynchronous Events
      8. 16.8 Multi-level Propagation
      9. 16.9 Static Checking
      10. 16.10 Invariants
    8. 17. Namespaces
      1. 17.1 Introduction
      2. 17.2 The Problem
      3. 17.3 Ideals for a Solution
      4. 17.4 The Solution: Namespaces
      5. 17.5 Implications for Classes
      6. 17.6 C Compatibility
    9. 18. The C Preprocessor
      1. 18.1 Cpp
  10. Index
  11. Code Snippets