从老外那边转的一个C++初学者要看的东东。

A Beginners C++

The table of contents given below includes links to additional materials. Some complete chapters, and various subsections, are available either as Postscript files or directly readable "html" text. There are also links to a couple of files with example code. The code should be usable with the Borland development environment for the PC, or Symantec-8 for the Macintosh.

To save space and transmission time, many of the Postscript files have been compressed. The files were compressed using gzip on Unix. You have to uncompress them (gunzip) before viewing them with ghostview or sending to a printer. (If you go to you will usually find that they have dowloadable copies of gzip utilities for both Mac and PC available on their page. The links are at the bottom after their stories about Java developments.) (If you need a viewer for postscript, try: )

---

The postscript files have been "distilled" into Adobe PDF files. This makes them smaller, and so easier to download; it should also make them easier to read on a variety of systems.

---

---

Part 1 Introduction to Computers

1. Computer Hardware
   
   1. CPU and instructions
   2. Memory and Data
   3. Bus
   4. Peripherals
   5. Disks and tapes
   6. Other I/O devices
2. Programs: Instructions in the Computer
   1. Programming with bits!
   2. Loaders
   3. Assemblers
   4. Coding in assembly language
   5. From Assembly Language to "High Level" languages
3. Operating Systems
   
   1. Origins of "Operating Systems"
   2. Development of Operating Systems: Multiprogramming* Timesharing* File Management* Virtual Memory* "Spooling"* Late 1960s early 1970s system* Networking*
   3. Modern systems: UNIX* Macintosh OS*
4. Why have "high-level" languages?
   1. Limitations of Assembly Language and Origins of High Level Languages
   2. High level languages constructs: Statements* Data types and structures*
   3. Evolution of high level languages
   4. FORTRAN
   5. BASIC
   6. Lisp
   7. COBOL
   8. ALGOL
   9. The "Algol Family":AlgolW, Pascal, and Modula2* ADA* BCPL, C, and C++* Simula, SmallTalk, and Eiffel*
5. C++ development environment
   1. Integrated Development Environment
   2. C++ input and output
   3. A simple example program in C++:Design* Implementation*

   ---

   Part 2 Simple Programs

6. Sequence
   1. Overall structure and main() Function
   2. Comments
   3. Variable definitions
   4. Statements
   5. Examples: "Exchange rates"* pH*
   6. Naming rules for variables
   7. Constants
   8. Initialization of Variables
   9. Converting data values
7. Iteration
   1. While loops
   2. Examples: Modelling the decay of CFC gases* Newton's method for finding a square root* Tabulating function values*
   3. Blocks
   4. "Boolean" variables and expressions True and False* Expressions using "AND"s and "OR"s*
   5. Short forms: C/C++ abbreviations
   6. Do ... while
   7. For loop
   8. Break and Continue statements
8. Selection
   1. Making choices
   3. IF...
   4. Terminating a program
   5. Example Programs: Calculating some simple statistics* Newton's method for roots of polynomials*
   6. What is the Largest? What is the Smallest?
9. Simple use of files
   1. Dealing with more data
   2. Defining filestream objects
   3. Using input and output filestreams
   4. Stream states
   5. Options when opening filestreams
   6. When to stop reading data?
   7. More Formatting options
   8. Example

   ---

   Part 3 Functions and Data Aggregates

10. Functions
    1. Form of a function Definition
    2. Result types
    3. Function declarations
    4. Default argument values
    5. Type safe linkage, Overloading, and Name Mangling
    6. How functions work
    7. Inline functions
    8. A recursive function
    9. Examples of simple functions: GetIntegerInRange* Newton's square root algorithm as a function*
    10. The rand() function
    11. Examples: pi-Canon* , Function plotter*
11. Arrays
    1. Defining one dimensional arrays
    2. Initializing one dimensional arrays
    3. Simple Examples Using One-Dimensional arrays: Histogram* Plotting once more*
    4. Arrays as arguments to functions
    5. Strings: Arrays of characters
    6. Multi-dimensional arrays: Definition and initialization* Accessing individual elements* As arguments to functions*
    7. Arrays of Fixed length Strings
    8. Examples using arrays: Letter Counts* Simple encryption* Simple image processing*
12. Programs with functions and arrays
    1. Curses
    2. Heat diffusion
    3. Menu Selection
    4. Pick the keyword
    5. Hangman ,
    6. Life
13. Standard algorithms
    1. Finding the Right Element: Binary Search: An iterative binary search routine* Isn't it a recursive problem?* What was the cost?
    2. Establishing Order
    3. A simple sort of sort
    4. Quicksort: a better sort of sort: The algorithm* An implementation* An enhanced implementation*
    5. Algorithms, Functions, and Subroutine Libraries
14. Tools ,
    1. The "Code Coverage" Tool
    2. The Profiler
15. Design and documentation : 1
    1. Top down functional decomposition
    2. Documenting a design
16. Enum, Struct, and Union
    1. Enumerated types
    2. structs
    3. Unions
17. Examples using structs
    1. Reordering the class list again
    2. Points and Rectangles
    3. File of Records
18. Bits and pieces
    1. Bit manipulations
    2. Making a Hash of it: Example hashing function for a character string* A simple "hash table"* Example: identifying the commonly used words*
    3. Coding "Property Vectors"
    4. Pieces (Bit fields)

    ---

    Part 4 A Touch of Class

19. Beginners' Class
    1. Class declarations and definitions: Form of a class declaration* Defining the member functions* Using class instances* Initialization and "constructor" functions* const member functions* inline member functions*
    2. Example: Bitmaps (Sets)
    3. Numbers - a more complex form of data
    4. A glance at the "iostream" classes
20. Dynamic data and pointers
    1. The "Heap"
    2. Pointers: Some "pointer" basics* Using pointers* Strings and hash tables revisited*
    3. Example: "Air Traffic Controller"
    4. The "address of" operator
    5. Pointers and Arrays
    6. Building Networks
21. Collections of data
    1. Class Queue
    2. Class PriorityQueue
    3. Class DynamicArray (code in C29 and C30 examples)
    4. Class List
    5. Class BinaryTree (code in C23 iterators example)
    6. Collection class Libraries
22. A World of Interacting Objects
    1. RefCards: Design* Implementation*
    2. InfoStore: Initial design outline for InfoStore* Design and Implementation of the Vocabulary class* Other classes in the InfoStore program* Final class design for the InfoStore program
23. Intermediate class
    1. Shared Class Properties
    2. Friends
    3. Iterators: ListIterator* TreeIterator*,
    4. Operator functions: Defining operator functions* Operator functions and the iostream library*
    5. Resource Manager Classes and Destructors: Resource management* Destructor functions* The assignment operator and copy constructors*
    6. Inheritance: Discovering similarities among prototype classes* Defining Class Hierarchies in C++* But how does it work?!* Multiple Inheritance* Using Inheritance
24. Two more "trees"
    1. AVL Trees: What's wrong with binary trees?* Keeping your balance* An implementation* Testing!*
    2. BTree: Multiway trees* A tree on a disk?* BTree: search, insertion, and deletion operations* An implementation* Testing* (code in C30 example)
25. Templates
    1. A general function and its specializations
    2. Language Extensions for Templates:Template declaration* Template instantiation*
    3. Specialized Instantiations of Template Code
    4. A Template Version of QuickSort
    5. The Template Class "Bounded Array"
    6. The Template Class Queue
26. Exceptions
    1. C++'s Exception Mechanism
    2. Example: Exceptions for class Number
    3. Identifying the Exceptions that you intend to throw
27. Example: Supermarket
    1. Background and Program Specification/li>
    2. Design: Design preliminaries* Scenarios: identifying objects, their classes, their responsibilities, their data* Filling out the definitions of the classes for a partial implementation*
    3. A partial implementation
    4. Finalising the Design: Histograms* Simulating the checkouts and their queues* Organizing the checkouts*
28. Design and documentation: 2
    1. Object-Based Design
    2. Documenting a design

    ---

    Part 5 Object Oriented Programming

    
    
29. The Power of Inheritance and Polymorphism
    1. The "Dungeon" Game
    3. ,
30. Reusable designs
    1. The RecordFile Framework: Concepts
    2. The Framework classes: Overview
    3. The Command Handler Classes: Class declarations* Interactions* Implementation Code*
    4. Collection Classes and their Adapters*
    5. Class Record
    6. The Windows Class Hierarchy: Class Responsibilities* Implementation Code* Using the concrete classes from a framework*
    7. Organizational Details
31. Frameworks for understanding
    1. "Resources" and "Macros"
    2. Architects, Experts, and Wizards
    3. Graphics
    4. Persistent Data
    5. The Event Handlers
    6. The Same Patterns in the code

--------------------next---------------------