Chapter 0 Getting started

0.1 Comments

0.2 #include

0.3 The main function

0.4 Curly braces

0.5 Using the standard library for output

0.6 The return statement

0.7 A slightly deeper look

0.8 Details

Chapter 1 Working with strings

1.1 Input

1.2 Framing a name

1.3 Details

Chapter 2 Looping and counting

2.1 The problem

2.2 Overall structure

2.3 Writing an unknown number of rows

2.4 Writing a row

2.5 The complete framing program

2.6 Counting

2.7 Details

Chapter 3 Working with batches of data

3.1 Computing student grades

3.2 Using medians instead of averages

3.3 Details

Chapter 4 Organizing programs and data

4.1 Organizing computations

4.2 Organizing data

4.3 Putting it all together

4.4 Partitioning the grading program

4.5 The revised grading program

4.6 Details

Chapter 5 Using sequential containers and analyzing strings

5.1 Separating students into categories

5.2 Iterators

5.3 Using iterators instead of indices

5.4 Rethinking our data structure for better performance

5.5 The 1 i s t type

5.6 Taking strings apart

5.7 Testing our split function

5.8 Putting strings together

5.9 Details

Chapter 6 Using library algorithms

6.1 Analyzing strings

6.2 Comparing grading schemes

6.3 Classifying students, revisited

6.4 Algorithms, containers, and iterators

6.5 Details

Chapter 7 Using associative containers

7.1 Containers that support efficient look-up

7.2 Counting words

7.3 Generating a cross-reference table

7.4 Generating sentences

7.5 A note on performance

7.6 Details

Chapter 8 Writing generic functions

8.1 What is a generic function?

8.2 Data-structure independence

8.3 Input and output iterators

8.4 Using iterators for flexibility

8.5 Details

Chapter 9 Defining new types

9.1 Student_info revisited

9.2 Class types

9.3 Protection

9.4 The Student_info class

9.5 Constructors

9.6 Using the Student_info class

9.7 Details

Chapter 10 Managing memory and low-level data structures

10.1 Pointers and arrays

10.2 String literals revisited

10.3 Initializing arrays of character pointers

10.4 Arguments to main

10.5 Reading and writing files

10.6 Three kinds of memory management

10.7 Details

Chapter 11 Defining abstract data types

11.1 The vec class

11.2 Implementing the vec class

11.3 Copy control

11.4 Dynamic Vecs

11.5 Flexible memory management

11.6 Details

Chapter 12 Making class objects act like values

12.1 A simple string class

12.2 Automatic conversions

12.3 Str operations

12.4 Some conversions are hazardous

12.5 Conversion operators

12.6 Conversions and memory management

12.7 Details

Chapter 13 Using inheritance and dynamic binding

13.1 Inheritance

13.2 Polymorphism and virtual functions

13.3 Using inheritance to solve our problem

13.4 A simple handle class

13.5 Using the handle class

13.6 Subtleties

13.7 Details

Chapter 14 Managing memory (almost) automatically

14.1 Handles that copy their objects

14.2 Reference-counted handles

14.3 Handles that let you decide when to share data

14.4 An improvement on controllable handles

14.5 Details

Chapter 15 Revisiting character pictures

15.1 Design

15.2 Implementation

15.3 Details

Chapter 16 Where do we go from here?

16.1 Use the abstractions you have

16.2 Learn more

Appendix A Language details

A.1 Declarations

A.2 Types

A.3 Expressions

A.4 Statements

Appendix B Library summary

B.1 Input-output

B.2 Containers and iterators

B.3 Algorithms

Index