C++ Primer Plus.

By:

Prata, Stephen

Material type: Text

TextPublication details: Boston, Mass. ; London Addison-Wesley, 2011Edition: 6th edDescription: xxi, 1420p. : ill. ; 23 cmISBN:

9780321776402
0321776402

Subject(s):

C++ (Computer program language)

Holdings
Item type	Current library	Call number	Copy number	Status	Date due	Barcode
Standard Loan	Thurles Library Main Collection	005.133 PRA (Browse shelf(Opens below))	1	Available		39002100501197
2 Hour Loan	Thurles Library Reserve - Library Issue Desk	005.133 PRA (Browse shelf(Opens below))	1	Library Use Only		39002100501205

Enhanced descriptions from Syndetics:

C++ Primer Plus, Sixth Edition

New C++11 Coverage

C++ Primer Plus is a carefully crafted, complete tutorial on one of the most significant and widely used programming languages today. An accessible and easy-to-use self-study guide, this book is appropriate for both serious students of programming as well as developers already proficient in other languages.
The sixth edition of C++ Primer Plus has been updated and expanded to cover the latest developments in C++, including a detailed look at the new C++11 standard.
Author and educator Stephen Prata has created an introduction to C++ that is instructive, clear, and insightful. Fundamental programming concepts are explained along with details of the C++ language. Many short, practical examples illustrate just one or two concepts at a time, encouraging readers to master new topics by immediately putting them to use.
Review questions and programming exercises at the end of each chapter help readers zero in on the most critical information and digest the most difficult concepts.
In C++ Primer Plus, you'll find depth, breadth, and a variety of teaching techniques and tools to enhance your learning:

A new detailed chapter on the changes and additional capabilities introduced in the C++11 standard Complete, integrated discussion of both basic C language and additional C++ features Clear guidance about when and why to use a feature Hands-on learning with concise and simple examples that develop your understanding a concept or two at a time Hundreds of practical sample programs Review questions and programming exercises at the end of each chapter to test your understanding Coverage of generic C++ gives you the greatest possible flexibility Teaches the ISO standard, including discussions of templates, the Standard Template Library, the string class, exceptions, RTTI, and namespaces Table of Contents

1: Getting Started with C++

2: Setting Out to C++

3: Dealing with Data

4: Compound Types

5: Loops and Relational Expressions

6: Branching Statements and Logical Operators

7: Functions: C++'s Programming Modules

8: Adventures in Functions

9: Memory Models and Namespaces

10: Objects and Classes

11: Working with Classes

12: Classes and Dynamic Memory Allocation

13: Class Inheritance

14: Reusing Code in C++

15: Friends, Exceptions, and More

16: The string Class and the Standard Template Library

17: Input, Output, and Files

18: The New C++11 Standard

A Number Bases

B C++ Reserved Words

C The ASCII Character Set

D Operator Precedence

E Other Operators

F The stringTemplate Class

G The Standard Template Library Methods and Functions

H Selected Readings and Internet Resources

I Converting to ISO Standard C++

J Answers to Chapter Reviews

Table of contents provided by Syndetics

Introduction (p. 1)
Chapter 1 Getting Started with C++ (p. 9)
Learning C++: What Lies Before You (p. 10)
The Origins of C++: A Little History (p. 10)
Portability and Standards (p. 15)
The Mechanics of Creating a Program (p. 18)
Summary (p. 25)
Chapter 2 Setting Out to C++ (p. 27)
C++ Initiation (p. 27)
C++ Statements (p. 41)
More C++ Statements (p. 45)
Functions (p. 48)
Summary (p. 61)
Chapter Review (p. 62)
Programming Exercises (p. 62)
Chapter 3 Dealing with Data (p. 65)
Simple Variables (p. 66)
The const Qualifier (p. 90)
Floating-Point Numbers (p. 92)
C++ Arithmetic Operators (p. 97)
Summary (p. 109)
Chapter Review (p. 110)
Programming Exercises (p. 111)
Chapter 4 Compound Types (p. 115)
Introducing Arrays (p. 116)
Strings (p. 120)
Introducing the string Class (p. 131)
Introducing Structures (p. 140)
Unions (p. 149)
Enumerations (p. 150)
Pointers and the Free Store (p. 153)
Pointers, Arrays, and Pointer Arithmetic (p. 167)
Combinations of Types (p. 184)
Array Alternatives (p. 186)
Summary (p. 190)
Chapter Review (p. 191)
Programming Exercises (p. 192)
Chapter 5 Loops and Relational Expressions (p. 195)
Introducing for Loops (p. 196)
The while Loop (p. 224)
The do while Loop (p. 231)
The Range-Based for Loop (C++11) (p. 233)
Loops and Text Input (p. 234)
Nested Loops and Two-Dimensional Arrays (p. 244)
Summary (p. 249)
Chapter Review (p. 250)
Programming Exercises (p. 251)
Chapter 6 Branching Statements and Logical Operators (p. 253)
The if Statement (p. 254)
Logical Expressions (p. 260)
The cctype Library of Character Functions (p. 270)
The ?: Operator (p. 273)
The switch Statement (p. 274)
The break and continue Statements (p. 280)
Number-Reading Loops (p. 283)
Simple File Input/Output (p. 287)
Summary (p. 298)
Chapter Review (p. 298)
Programming Exercises (p. 301)
Chapter 7 Functions: C++'s Programming Modules (p. 305)
Function Review (p. 306)
Function Arguments and Passing by Value (p. 313)
Functions and Arrays (p. 320)
Functions and Two-Dimensional Arrays (p. 337)
Functions and C-Style Strings (p. 339)
Functions and Structures (p. 343)
Functions and string Class Objects (p. 353)
Functions and array Objects (p. 355)
Recursion (p. 357)
Pointers to Functions (p. 361)
Summary (p. 371)
Chapter Review (p. 372)
Programming Exercises (p. 374)
Chapter 8 Adventures in Functions (p. 379)
C++ Inline Functions (p. 379)
Reference Variables (p. 383)
Default Arguments (p. 409)
Function Overloading (p. 412)
Function Templates (p. 419)
Summary (p. 442)
Chapter Review (p. 443)
Programming Exercises (p. 444)
Chapter 9 Memory Models and Namespaces (p. 447)
Separate Compilation (p. 447)
Storage Duration, Scope, and Linkage (p. 453)
Namespaces (p. 482)
Summary (p. 497)
Chapter Review (p. 498)
Programming Exercises (p. 501)
Chapter 10 Objects and Classes (p. 505)
Procedural and Object-Oriented Programming (p. 506)
Abstraction and Classes (p. 507)
Class Constructors and Destructors (p. 524)
Knowing Your Objects: The this Pointer (p. 539)
An Array of Objects (p. 546)
Class Scope (p. 549)
Abstract Data Types (p. 552)
Summary (p. 557)
Chapter Review (p. 558)
Programming Exercises (p. 559)
Chapter 11 Working with Classes (p. 563)
Operator Overloading (p. 564)
Time on Our Hands: Developing an Operator Overloading Example (p. 565)
Introducing Friends (p. 578)
Overloaded Operators: Member Versus Nonmember Functions (p. 587)
More Overloading: A Vector Class (p. 588)
Automatic Conversions and Type Casts for Classes (p. 606)
Summary (p. 621)
Chapter Review (p. 623)
Programming Exercises (p. 623)
Chapter 12 Classes and Dynamic Memory Allocation (p. 627)
Dynamic Memory and Classes (p. 628)
The New, Improved String Class (p. 647)
Things to Remember When Using new in Constructors (p. 659)
Observations About Returning Objects (p. 662)
Using Pointers to Objects (p. 665)
Reviewing Techniques (p. 676)
A Queue Simulation (p. 678)
Summary (p. 699)
Chapter Review (p. 700)
Programming Exercises (p. 702)
Chapter 13 Class Inheritance (p. 707)
Beginning with a Simple Base Class (p. 708)
Inheritance: AnIs-aRelationship (p. 720)
Polymorphic Public Inheritance (p. 722)
Static and Dynamic Binding (p. 737)
Access Control: protected (p. 745)
Abstract Base Classes (p. 746)
Inheritance and Dynamic Memory Allocation (p. 757)
Class Design Review (p. 766)
Summary (p. 778)
Chapter Review (p. 779)
Programming Exercises (p. 780)
Chapter 14 Reusing Code in C++ (p. 785)
Classes with Object Members (p. 786)
Private Inheritance (p. 797)
Multiple Inheritance (p. 808)
Class Templates (p. 830)
Summary (p. 866)
Chapter Review (p. 869)
Programming Exercises (p. 871)
Chapter 15 Friends, Exceptions, and More (p. 877)
Friends (p. 877)
Nested Classes (p. 889)
Exceptions (p. 896)
Runtime Type Identification (p. 933)
Type Cast Operators (p. 943)
Summary (p. 947)
Chapter Review (p. 947)
Programming Exercises (p. 949)
Chapter 16 The string Class and the Standard Template Library (p. 951)
The string Class (p. 952)
Smart Pointer Template Classes (p. 968)
The Standard Template Library (p. 978)
Generic Programming (p. 992)
Function Objects (a.k.a. Functors) (p. 1026)
Algorithms (p. 1035)
Other Libraries (p. 1045)
Chapter 17 Input, Output, and Files (p. 1061)
An Overview of C++ Input and Output (p. 1062)
Output with cout (p. 1069)
Input with cin (p. 1093)
File Input and Output (p. 1114)
Incore Formatting (p. 1142)
Summary (p. 1145)
Chapter Review (p. 1146)
Programming Exercises (p. 1148)
Chapter 18 Visiting with the New C++ Standard (p. 1153)
C++11 Features Revisited (p. 1153)
Move Semantics and the Rvalue Reference (p. 1164)
New Class Features (p. 1178)
Lambda Functions (p. 1184)
Wrappers (p. 1191)
Variadic Templates (p. 1197)
More C++11 Features (p. 1202)
Language Change (p. 1205)
What Now? (p. 1207)
Summary (p. 1208)
Chapter Review (p. 1209)
Programming Exercises (p. 1212)
Appendixes
A Number Bases (p. 1215)
B C++ Reserved Words (p. 1221)
C The ASCII Character Set (p. 1225)
D Operator Precedence (p. 1231)
E Other Operators (p. 1235)
F The stringTemplate Class (p. 1249)
G The Standard Template Library Methods and Functions (p. 1271)
H Selected Readings and Internet Resources (p. 1323)
I Converting to ISO Standard C++ (p. 1327)
J Answers to Chapter Reviews (p. 1335)
Index (p. 1367)

Excerpt provided by Syndetics

Introduction Preface to the Fifth Edition Learning C++ is an adventure of discovery, particularly because the language accommodates several programming paradigms, including object-oriented programming, generic programming, and the traditional procedural programming. C++ was a moving target as the language added new features, but now, with the ISO/ANSI C++ Standard, Second Edition (2003), in place, the language has stabilized. Contemporary compilers support most or all of the features mandated by the standard, and programmers have had time to get used to applying these features. The fifth edition of this book, C++ Primer Plus, reflects the ISO/ANSI standard and describes this matured version of C++. C++ Primer Plus discusses the basic C language and presents C++ features, making this book self-contained. It presents C++ fundamentals and illustrates them with short, to-the-point programs that are easy to copy and experiment with. You'll learn about input/output (I/O), how to make programs perform repetitive tasks and make choices, the many ways to handle data, and how to use functions. You'll learn about the many features C++ has added to C, including the following: Classes and objects Inheritance Polymorphism, virtual functions, and runtime type identification (RTTI) Function overloading Reference variables Generic, or type-independent, programming, as provided by templates and the Standard Template Library (STL) The exception mechanism for handling error conditions Namespaces for managing names of functions, classes, and variables The Primer Approach C++ Primer Plus brings several virtues to the task of presenting all this material. It builds on the primer tradition begun by C Primer Plus nearly two decades ago and embraces its successful philosophy: A primer should be an easy-to-use, friendly guide. A primer doesn't assume that you are already familiar with all relevant programming concepts. A primer emphasizes hands-on learning with brief, easily typed examples that develop your understanding, a concept or two at a time. A primer clarifies concepts with illustrations. A primer provides questions and exercises to let you test your understanding, making the book suitable for self-learning or for the classroom. Following these principles, the book helps you understand this rich language and how to use it. For example: It provides conceptual guidance about when to use particular features, such as using public inheritance to model what are known as is-a relationships. It illustrates common C++ programming idioms and techniques. It provides a variety of sidebars, including tips, cautions, things to remember, compatibility notes, and real-world notes. The author and editors of this book do our best to keep the presentation to-the-point, simple, and fun. Our goal is that by the end of the book, you'll be able to write solid, effective programs and enjoy yourself doing so. Sample Code Used in This Book This book provides an abundance of sample code, most of it in the form of complete programs. Like the previous editions, this book practices generic C++ so that it is not tied to any particular kind of computer, operating system, or compiler. Thus, the examples were tested on a Windows XP system, a Macintosh OS X system, and a Linux system. Only a few programs were affected by compiler non-conformance issues. Compiler compliance with the C++ standard has improved since the previous edition of this book first appeared. The sample code for the complete programs described in this book is available on the Sams website, at http://www.samspublishing.com . Enter this book's ISBN (without the hyphens) in the Search box and click Search. When the book's title is displayed, click the title to go to a page where you can download the code. You also can find solutions to selected programming exercises at this site. How This Book Is Organized This book is divided into 17 chapters and 10 appendixes, summarized here. Chapter 1: Getting Started Chapter 1 relates how Bjarne Stroustrup created the C++ programming language by adding object-oriented programming support to the C language. You'll learn the distinctions between procedural languages, such as C, and object-oriented languages, such as C++. You'll read about the joint ANSI/ISO work to develop a C++ standard. This chapter discusses the mechanics of creating a C++ program, outlining the approach for several current C++ compilers. Finally, it describes the conventions used in this book. Chapter 2: Setting Out to C++ Chapter 2 guides you through the process of creating simple C++ programs. You'll learn about the role of the main() function and about some of the kinds of statements that C++ programs use. You'll use the predefined cout and cin objects for program output and input, and you'll learn about creating and using variables. Finally, you'll be introduced to functions, C++'s programming modules. Chapter 3: Dealing with Data C++ provides built-in types for storing two kinds of data: integers (numbers with no fractional parts) and floating-point numbers (numbers with fractional parts). To meet the diverse requirements of programmers, C++ offers several types in each category. Chapter 3 discusses those types, including creating variables and writing constants of various types. You'll also learn how C++ handles implicit and explicit conversions from one type to another. Chapter 4: Compound Types C++ lets you construct more elaborate types from the basic built-in types. The most advanced form is the class, discussed in Chapters 9 through 13. Chapter 4 discusses other forms, including arrays, which hold several values of a single type; structures, which hold several values of unlike types; and pointers, which identify locations in memory. You'll also learn how to create and store text strings and to handle text I/O by using C-style character arrays and the C++ string class. Finally, you'll learn some of the ways C++ handles memory allocation, including using the new and delete operators for managing memory explicitly. Chapter 5: Loops and Relational Expressions Programs often must perform repetitive actions, and C++ provides three looping structures for that purpose: the for loop, the while loop, and the do while loop. Such loops must know when they should terminate, and the C++ relational operators enable you to create tests to guide such loops. In Chapter 5 you learn how to create loops that read and process input character-by-character. Finally, you'll learn how to create two-dimensional arrays and how to use nested loops to process them. Chapter 6: Branching Statements and Logical Operators Programs can behave intelligently if they can tailor their behavior to circumstances. In Chapter 6 you'll learn how to control program flow by using the if , if else , and switch statements and the conditional operator. You'll learn how to use logical operators to help express decision-making tests. Also, you'll meet the cctype library of functions for evaluating character relations, such as testing whether a character is a digit or a nonprinting character. Finally, you'll get an introductory view of file I/O. Chapter 7: Functions: C++'s Programming Modules Functions are the basic building blocks of C++ programming. Chapter 7 concentrates on features that C++ functions share with C functions. In particular, you'll review the general format of a function definition and examine how function prototypes increase the reliability of programs. Also, you'll investigate how to write functions to process arrays, character strings, and structures. Next, you'll learn about recursion, which is when a function calls itself, and see how it can be used to implement a divide-and-conquer strategy. Finally, you'll meet pointers to functions, which enable you to use a function argument to tell one function to use a second function. Chapter 8: Adventures in Functions Chapter 8 explores the new features C++ adds to functions. You'll learn about inline functions, which can speed program execution at the cost of additional program size. You'll work with reference variables, which provide an alternative way to pass information to functions. Default arguments let a function automatically supply values for function arguments that you omit from a function call. Function overloading lets you create functions having the same name but taking different argument lists. All these features have frequent use in class design. Also, you'll learn about function templates, which allow you to specify the design of a family of related functions. Chapter 9: Memory Models and Namespaces Chapter 9 discusses putting together multifile programs. It examines the choices in allocating memory, looking at different methods of managing memory and at scope, linkage, and namespaces, which determine what parts of a program know about a variable. Chapter 10: Objects and Classes A class is a user-defined type, and an object (such as a variable) is an instance of a class. Chapter 10 introduces you to object-oriented programming and to class design. A class declaration describes the information stored in a class object and also the operations (class methods) allowed for class objects. Some parts of an object are visible to the outside world (the public portion), and some are hidden (the private portion). Special class methods (constructors and destructors) come into play when objects are created and destroyed. You will learn about all this and other class details in this chapter, and you'll see how classes can be used to implement ADTs, such as a stack. Chapter 11: Working with Classes In Chapter 11 you'll further your understanding of classes. First, you'll learn about operator overloading, which lets you define how operators such as + will work with class objects. You'll learn about friend functions, which can access class data that's inaccessible to the world at large. You'll see how certain constructors and overloaded operator member functions can be used to manage conversion to and from class types. Chapter 12: Classes and Dynamic Memory Allocation Often it's useful to have a class member point to dynamically allocated memory. If you use new in a class constructor to allocate dynamic memory, you incur the responsibilities of providing an appropriate destructor, of defining an explicit copy constructor, and of defining an explicit assignment operator. Chapter 12 shows you how and discusses the behavior of the member functions generated implicitly if you fail to provide explicit definitions. You'll also expand your experience with classes by using pointers to objects and studying a queue simulation problem. Chapter 13: Class Inheritance One of the most powerful features of object-oriented programming is inheritance, by which a derived class inherits the features of a base class, enabling you to reuse the base class code. Chapter 13 discusses public inheritance, which models is-a relationships, meaning that a derived object is a special case of a base object. For example, a physicist is a special case of a scientist. Some inheritance relationships are polymorphic, meaning you can write code using a mixture of related classes for which the same method name may invoke behavior that depends on the object type. Implementing this kind of behavior necessitates using a new kind of member function called a virtual function. Sometimes using abstract base classes is the best approach to inheritance relationships. This chapter discusses these matters, pointing out when public inheritance is appropriate and when it is not. Chapter 14: Reusing Code in C++ Public inheritance is just one way to reuse code. Chapter 14 looks at several other ways. Containment is when one class contains members that are objects of another class. It can be used to model has-a relationships, in which one class has components of another class. For example, an automobile has a motor. You also can use private and protected inheritance to model such relationships. This chapter shows you how and points out the differences among the different approaches. Also, you'll learn about class templates, which let you define a class in terms of some unspecified generic type, and then use the template to create specific classes in terms of specific types. For example, a stack template enables you to create a stack of integers or a stack of strings. Finally, you'll learn about multiple public inheritance, whereby a class can derive from more than one class. Chapter 15: Friends, Exceptions, and More Chapter 15 extends the discussion of friends to include friend classes and friend member functions. Then it presents several new developments in C++, beginning with exceptions, which provide a mechanism for dealing with unusual program occurrences, such an inappropriate function argument values and running out of memory. Then you'll learn about RTTI, a mechanism for identifying object types. Finally, you'll learn about the safer alternatives to unrestricted typecasting. Chapter 16: The string Class and the Standard Template Library Chapter 16 discusses some useful class libraries recently added to the language. The string class is a convenient and powerful alternative to traditional C-style strings. The auto_ptr class helps manage dynamically allocated memory. The STL provides several generic containers, including template representations of arrays, queues, lists, sets, and maps. It also provides an efficient library of generic algorithms that can be used with STL containers and also with ordinary arrays. The valarray template class provides support for numeric arrays. Chapter 17: Input, Output, and Files Chapter 17 reviews C++ I/O and discusses how to format output. You'll learn how to use class methods to determine the state of an input or output stream and to see, for example, whether there has been a type mismatch on input or whether the end-of-file has been detected. C++ uses inheritance to derive classes for managing file input and output. You'll learn how to open files for input and output, how to append data to a file, how to use binary files, and how to get random access to a file. Finally, youlearn how to apply standard I/O methods to read from and write to strings. Appendix A: Number Bases Appendix A discusses octal, hexadecimal, and binary numbers. Appendix B: C++ Reserved Words Appendix B lists C++ keywords. Appendix C: The ASCII Character Set Appendix C lists the ASCII character set, along with decimal, octal, hexadecimal, and binary representations. Appendix D: Operator Precedence Appendix D lists the C++ operators in order of decreasing precedence. Appendix E: Other Operators Appendix E summarizes the C++ operators, such as the bitwise operators, not covered in the main body of the text. Appendix F: The string Template Class Appendix F summarizes string class methods and functions. Appendix G: The STL Methods and Functions Appendix G summarizes the STL container methods and the general STL algorithm functions. Appendix H: Selected Readings and Internet Resources Appendix H lists some books that can further your understanding of C++. Appendix I: Converting to ANSI/ISO Standard C++ Appendix I provides guidelines for moving from C and older C++ implementations to ANSI/ISO C++. Appendix J: Answers to Review Questions Appendix J contains the answers to the review questions posed at the end of each chapter. Note to Instructors One of the goals of this edition of C++ Primer Plus is to provide a book that can be used as either a teach-yourself book or as a textbook. Here are some of the features that support using C++ Primer Plus, Fifth Edition, as a textbook: This book describes generic C++, so it isn't dependent on a particular implementation. The contents track the ISO/ANSI C++ standards committee's work and include discussions of templates, the STL, the string class, exceptions, RTTI, and namespaces. It doesn't assume prior knowledge of C, so it can be used without a C prerequisite. (Some programming background is desirable, however.) Topics are arranged so that the early chapters can be covered rapidly as review chapters for courses that do have a C prerequisite. Chapters include review questions and programming exercises. Appendix J provides the answers to the review questions. Solutions to selected programming exercises can be found at the Sams website ( http://www.samspublishing.com ). The book introduces several topics that are appropriate for computer science courses, including abstract data types (ADTs), stacks, queues, simple lists, simulations, generic programming, and using recursion to implement a divide-and-conquer strategy. Most chapters are short enough to cover in a week or less. The book discusses when to use certain features as well as how to use them. For example, it links public inheritance to is-a relationships and composition and private inheritance to has-a relationships, and it discusses when to use virtual functions and when not to. Conventions Used in This Book This book uses several typographic conventions to distinguish among various kinds of text: Code lines, commands, statements, variables, filenames, and program output appear in a computer typeface : #include int main(){{ using namespace std; cout << "What's up, Doc!\ n"; return 0;}} Program input that you should type appears in bold computer typeface : Please enter your name: Plato Placeholders in syntax descriptions appear in an italic computer typeface. You should replace a placeholder with the actual filename, parameter, or whatever element it represents. Italic type is used for new terms. This book includes several elements intended to illuminate specific points: Compatibility Note - Most compilers are not yet 100% compliant with the ISO/ANSI Standard, and these notes warn you of discrepancies you may encounter. Remember - These notes highlight points that are important to remember. Real-World Note - Several professional programmers offer observations based on their experiences. Sidebar - A sidebar provides a deeper discussion or additional background to help illuminate a topic. Tip - Tips present short, helpful guides to particular programming situations. Caution - A caution alerts you to potential pitfalls. Note - The notes provide a catch-all category for comments that don't fall into one of the other categories. Systems Used to Develop This Book's Programming Examples For the record, the examples in this book were developed using Microsoft Visual C++ 7.1 (the version that comes with Microsoft Visual Studio .NET 2003) and Metrowerks CodeWarrior Development Studio 9 on a Pentium PC with a hard disk and running under Windows XP Professional. Most programs were checked using the Borland C++ 5.5 command-line compiler and GNU gpp 3.3.3 on the same system, using Comeau 4.3.3 and GNU g++ 3.3.1 on an IBM-compatible Pentium running SuSE 9.0 Linux, and using Metrowerks Development Studio 9 on a Macintosh G4 under OS 10.3. This book reports discrepancies stemming from lagging behind the standard generically, as in "older implementations use ios::fixed instead of ios_base::fixed ." This book reports some bugs and idiosyncrasies in older compilers that would prove troublesome or confusing; most of these have been fixed in current releases. C++ offers a lot to the programmer; learn and enjoy! (c) Copyright Pearson Education. All rights reserved. Excerpted from C++ Primer Plus by Stephen Prata All rights reserved by the original copyright owners. Excerpts are provided for display purposes only and may not be reproduced, reprinted or distributed without the written permission of the publisher.

Author notes provided by Syndetics

Stephen Prata taught astronomy, physics, and computer science at the College of Marin in Kentfield, California. He received his B.S. from the California Institute of Technology and his Ph.D. from the University of California, Berkeley. He has authored or coauthored more than a dozen books on programming topics including New C Primer Plus, which received the Computer Press Association's 1990 Best How-to Computer Book Award, and C++ Primer Plus, nominated for the Computer Press Association's Best How-to Computer Book Award in 1991.