The Waite Group's C++ Programming

From years of experiments and research, AT&T Bell Laboratories has created C++, successor to the immensely popular C programming language. Already used in many AT&T projects, C++ has rapidly gained acceptance throughout universities and commercial programming shops. The major improvement in C++ over standard C is in the area of data abstraction. C++ makes it possible to create custom data types and special operators and functions that act on them. This leads to a new approach to data structures, called "object-oriented" programming.

The Waite Group's C++ Programming is a complete guide and tutorial to the C++ language. Aimed at the intermediate-to-advanced C programmer, the book stresses the unique, object-oriented mesaging capabilities of this exciting new extension to C, including:

• input and output message streams
• pointers and reference
• classes and inheritance
• function and operator overloading
• constructors and destructors

Written in The Waite Group's friendly, hands-on style, this book teaches through examples as linked lists, derived hierarchies of classes, a complete MS-DOS communications program using a derived class to add telecommunications capabilities, and UNIX System V semaphor manipulation.

All examples are compatible with C++ translators and compilers available for both UNIX and MS-DOS operating systems. Individual chapters discuss C++ programming under each of these operating systems. Because the book contains exercises and quizzes, it is ideal for both self-study and as the basis for a one-semester course.

1. Writing Your First C++ Program
• C++ Is Derived from C
• The Form of a C++ Program
• Overall Similarity of C and C++
• C++ Is Not Only C
• Declarations in C++
• The Scope of a Variable
• Storage Classes in C++
• Free Store Objects — A Fifth Storage Class
• Declaring a Constant Value in C++
• Pointers in C++
• void Pointers in C++
• Pointers and const
• What's Unique About C++
• Simple I/O in C++
• Function Definition in C++
• Function Overloading
• The class Data Type
• Simple and Not So Simple Classes
• Classes and Objects
• Changing the Meaning of Operators Through Overloading
• Derived Classes
• Creating a C++ Program
• The Source File and Naming Conventions
• Developing an Example Program
• Compiling the Program
• Summary
2. Using Functions in C++
• Enhanced Function Syntax in C++
• Function Declarations
• Function Return Values and the void Type
• Function Definitions
• A Complete C++ Program
• Providing Parameters with Default Values
• Call By Reference
• Declaring Reference Variable
• Call By Reference in C++
• inline Expanded Functions
• inline Functions in C++
• Defining an inline Function
• Creating Versatile Functions with Overloading
• Declaring an Overloaded Function
• Functions with a Variable Number of Parameters
• Specifying a Variable Number of Parameters
• Pointers and the const Modifier
• Summary
3. Defining and Using Classes
• Data Representation
• The Problem of Data Representation in C
• Representing Data with Objects
• Modularity and Data Hiding in C
• Files as Modules in C
• Modules as Objects
• The Mechanics of the C++ Class
• Comparing C and C++ Solutions to Data Representations
• Complete Classes in C++
• Private vs. Public Members of a Class
• Nested Classes
• Summary
4. Creating Complex Classes
• Creating Class Objects: Constructors and Destructors
• Constructors
• Destructors
• Global Constructors and Destructors
• The Action Part of a Class
• inline Functions in Classes
• Overloading Member Function Names
• Creating a friend Function
• Friends as Bridges Between Classes
• Member Functions as Friends to Other Functions
• Classes and Pointers
• Linked Data Structures Using Classes
• Container Classes
• Summary
5. Overloading Operators
• A Review of Overloading
• Function Overloading
• Extending Overloading to Operators
• Advantages of Operator Overloading
• The Mechanics of Operator Overloading
• Overloading Binary Operators
• Operators with Two Class Objects
• Using friend Operator Functions for Flexibility
• Operators with Multiple Overloadings
• Creating Unary Operators
• Combination Operators
• Overloading the () symbol
• A Two-Dimensional String Class
• Summary
6. Deriving Classes
• Derived Classes as a Development Tool
• Derived Classes for Better Data Representation
• Derived Classes Promote Modularity
• Derived Classes Enhance Efficiency
• Class Derivation: A Case Study
• Creating a Derived Class
• Access to the Base Class
• Multiple Derived Classes
• Explicit References to Members
• Derived Classes with Constructors and Destructors
• Coordination Between Base and Derived Classes
• Using the Base Class Constructor
• Private and Public Base Classes
• Public Base Classes
• Creating a Base Class with a Protected Section
• Virtual Function
• Complicated Systems of Classes
• Summary
7. Using the C++ Input/Output System
• Basic Input and Output in C++
• The C++ Approach to I/O
• The << and >> I/O Operators
• The Stream Class
• The Stream I/O Model
• The Standard I/O Streams
• The Input Operator >> and the Standard Input Stream
• Flexibility of the >> Operator
• The General-Purpose istream Input Function
• The Output Operator << and the Standard Output Stream
• The ostream Output Functions
• Formatted Output Functions
• Using the Standard Stream Objects
• Disk File Input and Output
• Opening a File
• Attaching a File to a Stream
• Output and Input with a File
• Testing the State of a Stream
• A Practical File Program
• The Standard I/O Functions and the Stream Library
• Using the Stream Library with User-Defined Data Types
• Redefining ostream
• The Direct Input of User-Defined Types
• Summary
8. Using C++ with MS-DOS
• The Project: Creating a Serial Port Object
• Basic Elements of the Serial Port
• The Software Port
• Sending a Byte from Port to Port
• Transmitting a Character
• Receiving a Character
• A Serial Port Class
• An Enhanced port Class
• A Hierarchy of port Classes
• The Base Class
• The Derived Class serial
• Packaging a Class
• Two Tasks in Creating a Class Data Type
• Compiling and Forgetting
• The Complete port and serial Class Listing
• Summary
9. Using C++ on the UNIX System
   E. William Leggett
• A Brief Introduction to UNIX
• Why Use C++ Under UNIX?
• Using UNIX Systems Multitasking
• Names Pipes or FIFOs
• UNIX IPC Messages
• Shared Memory
• Semaphores
• Monitors and Critical Regions with System V
• Problems in Concurrent Processing
• Avoiding Concurrent Processing Problems
• Developing the Shared Memory Error Log
• Starting the Development Process
• An Overview of Program Files
• Constants and Key Values
• Defining the Shared Memory Log Class
• Using Semaphores: The semaset Class
• The Semaphore Operations
• Waiting for "non-full" and "non-empty" Conditions
• Semaphore wait() and post() Member
• Functions
• What to Do About "UNDO"
• The Semaphore Set System Call
• Leaving the Monitor
• Writing and Reading Messages
• Writing Messages
• Reading Messages
• Some Design Issues
• Constructors and Destructors
• Other Functions
• Reader and Writer Test Processes
• Summary

Buy something else.