?nbsp; Table of Contents ?nbsp; Index

C++ Primer Plus, Fourth Edition By Stephen Prata     Publisher : Sams Publishing Pub Date : November 14, 2001 ISBN : 0672322234 Pages : 1128 C++ Primer Plus, Fourth Edition presents the ANSI C++ standard beginning with a discussion of the essential elements of C++ programming: loops, expressions, functions, and classes. It walks readers through the basics of object-oriented programming: classes, inheritance, templates, and exceptions, as well as the latest object-oriented programming techniques. C++ Primer Plus contains hundreds of sample programs. The friendly tone, concise programs, and end-of-chapter review exercises allow beginners to write their own programs immediately. 777

		Copyright
		PREFACE
			Preface to the Fourth Edition
			Note to Instructors
			How This Book Is Organized
		ABOUT THE AUTHOR
		ACKNOWLEDGMENTS
		TELL US WHAT YOU THINK!
		Chapter 1.  GETTING STARTED
			Learning C++
			A Little History
			Portability and Standards
			The Mechanics of Creating a Program
			Conventions Used in This Book
			Our System
		Chapter 2.  SETTING OUT TO C++
			C++ Initiation
			More About C++ Statements
			More C++ Statements
			Functions
			Summary
			Review Questions
			Programming Exercises
		Chapter 3.  DEALING WITH DATA
			Simple Variables
			The const Qualifier
			Floating-Point Numbers
			C++ Arithmetic Operators
			Summary
			Review Questions
			Programming Exercises
		Chapter 4.  COMPOUND TYPES
			Introducing Arrays
			Strings
			Introducing Structures
			Unions
			Enumerations
			Pointers and the Free Store
			Pointers, Arrays, and Pointer Arithmetic
			Summary
			Review Questions
			Programming Exercises
		Chapter 5.  LOOPS AND RELATIONAL EXPRESSIONS
			Introducing the for Loop
			Relational Expressions
			The while Loop
			The do while Loop
			Loops and Text Input
			Nested Loops and Two-Dimensional Arrays
			Summary
			Review Questions
			Programming Exercises
		Chapter 6.  BRANCHING STATEMENTS AND LOGICAL OPERATORS
			The if Statement
			Logical Expressions
			The cctype Library of Character Functions
			The ?: Operator
			The switch Statement
			The break and continue Statements
			Number-Reading Loops
			Summary
			Review Questions
			Programming Exercises
		Chapter 7.  FUNCTIONS—C++'S PROGRAMMING MODULES
			Function Review
			Function Arguments and Passing by Value
			Functions and Arrays
			Functions and Two-Dimensional Arrays
			Functions and C-Style Strings
			Functions and Structures
			Recursion
			Pointers to Functions
			Summary
			Review Questions
			Programming Exercises
		Chapter 8.  ADVENTURES IN FUNCTIONS
			Inline Functions
			Reference Variables
			Default Arguments
			Function Polymorphism (Function Overloading)
			Function Templates
			Summary
			Review Questions
			Programming Exercises
		Chapter 9.  MEMORY MODELS AND NAMESPACES
			Separate Compilation
			Storage Duration, Scope, and Linkage
			Namespaces
			Summary
			Review Questions
			Programming Exercises
		Chapter 10.  OBJECTS AND CLASSES
			Procedural and Object-Oriented Programming
			Abstraction and Classes
			Class Constructors and Destructors
			Knowing Your Objects: The this Pointer
			An Array of Objects
			Class Scope
			An Abstract Data Type
			Summary
			Review Questions
			Programming Exercises
		Chapter 11.  WORKING WITH CLASSES
			Operator Overloading
			Time on Our Hands
			Introducing Friends
			Overloaded Operators: Member Versus Nonmember Functions
			More Overloading: A Vector Class
			Automatic Conversions and Type Casts for Classes
			Summary
			Review Questions
			Programming Exercises
		Chapter 12.  CLASSES AND DYNAMIC MEMORY ALLOCATION
			Dynamic Memory and Classes
			A Queue Simulation
			Summary
			Review Questions
			Programming Exercises
		Chapter 13.  CLASS INHERITANCE
			Beginning with a Simple Base Class
			Special Relationships
			Inheritance—An Is-a Relationship
			Polymorphic Public Inheritance
			Access Control-protected
			Abstract Base Classes
			Inheritance and Dynamic Memory Allocation
			Class Design Review
			Summary
			Review Questions
			Programming Exercises
		Chapter 14.  REUSING CODE IN C++
			Classes with Object Members
			Private Inheritance
			Multiple Inheritance
			Class Templates
			Summary
			Review Questions
			Programming Exercises
		Chapter 15.  FRIENDS, EXCEPTIONS, AND MORE
			Friends
			Nested Classes
			Exceptions
			RTTI
			Type Cast Operators
			Summary
			Review Questions
			Programming Exercises
		Chapter 16.  THE string CLASS AND THE STANDARD TEMPLATE LIBRARY
			The string Class
			The auto_ptr Class
			The Standard Template Library
			Generic Programming
			Function Objects (aka Functors)
			Algorithms
			Other Libraries
			Summary
			Review Questions
			Programming Exercises
		Chapter 17.  INPUT, OUTPUT, AND FILES
			An Overview of C++ Input and Output
			Output with cout
			Input with cin
			File Input and Output
			Incore Formatting
			What Now?
			Summary
			Review Questions
			Programming Exercises
		Appendix A.  NUMBER BASES
			Octal Integers
			Hexadecimal Numbers
			Binary Numbers
			Binary and Hex
		Appendix B.  C++ KEYWORDS
		Appendix C.  THE ASCII CHARACTER SET
		Appendix D.  OPERATOR PRECEDENCE
		Appendix E.  OTHER OPERATORS
			Bitwise Operators
			Member Dereferencing Operators
		Appendix F.  THE string TEMPLATE CLASS
			Thirteen Types and a Constant
			Data Information, Constructors, and So On
			String Access
			Basic Assignment
			String Searching
			Comparison Methods and Functions
			String Modifiers
			Output and Input
		Appendix G.  THE STL METHODS AND FUNCTIONS
			Members Common to All Containers
			Additional Members for Vectors, Lists, and Deques
			Additional Members for Sets and Maps
			STL Functions
		Appendix H.  SELECTED READINGS
		Appendix I.  CONVERTING TO ANSI/ISO STANDARD C++
			Preprocessor Directives
			Use Function Prototypes
			Type Casts
			Become Familiar with C++ Features
			Use the New Header Organization
			Use Namespaces
			Use the autoptr Template
			Use the string Class
			Use the STL
		Appendix J.  ANSWERS TO REVIEW QUESTIONS
			Chapter 2
			Chapter 3
			Chapter 4
			Chapter 5
			Chapter 6
			Chapter 7
			Chapter 8
			Chapter 9
			Chapter 10
			Chapter 11
			Chapter 12
			Chapter 13
			Chapter 14
			Chapter 15
			Chapter 16
			Chapter 17
		Index

Copyright

Copyright ?002 by Sams Publishing

All rights reserved. No part of this book shall be reproduced, stored in a retrieval system, or transmitted by any means, electronic, mechanical, photocopying, recording, or otherwise, without written permission from the publisher. No patent liability is assumed with respect to the use of the information contained herein. Although every precaution has been taken in the preparation of this book, the publisher and author assume no responsibility for errors or omissions. Nor is any liability assumed for damages resulting from the use of the information contained herein.

Library of Congress Catalog Card Number: 2001089224

Printed in the United States of America

First Printing: November 2001

03 02 01 00 4 3 2 1

Trademarks

All terms mentioned in this book that are known to be trademarks or service marks have been appropriately capitalized. Sams Publishing cannot attest to the accuracy of this information. Use of a term in this book should not be regarded as affecting the validity of any trademark or service mark.

Warning and Disclaimer

Every effort has been made to make this book as complete and as accurate as possible, but no warranty or fitness is implied. The information provided is on an "as is" basis. The author and the publisher shall have neither liability nor responsibility to any person or entity with respect to any loss or damages arising from the information contained in this book or from the use of the programs accompanying it.

Credits

ASSOCIATE PUBLISHER

Linda Engelman

ACQUISITIONS EDITOR

Linda Scharp

DEVELOPMENT EDITOR

Karen Wachs

MANAGING EDITOR

Charlotte Clapp

INDEXER

Kelly Castell

PROOFREADERS

Bob LaRoche

Jessica McCarty

TECHNICAL EDITORS

Philippe Bruno

Bill Craun

Michael Maddox

Chris Maunder

TEAM COORDINATOR

Lynne Williams

INTERIOR DESIGNER

Gary Adair

COVER DESIGNER

Gary Adair

PAGE LAYOUT

Ayanna Lacey

Stacey Richwine-DeRome

DEDICATION

To my colleagues and students at the College of Marin, with whom it is a pleasure to work.

—Stephen Prata

PREFACE

• Preface to the Fourth Edition
• Note to Instructors
• How This Book Is Organized

Preface to the Fourth 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++ has been a moving target as the language added new features, but now, with the ISO/ANSI C++ Standard of 1998 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 Fourth Edition of C++ Primer Plus reflects the ISO/ANSI standard and describes this matured version of C++.

C++ Primer Plus integrates discussing the basic C language with presenting 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 and output, 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 RTTI (runtime type identification)

• 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

C++ Primer Plus brings several virtues to the task of presenting all this material. It builds upon 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 already are 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.

The book helps you understand this rich language and how to use it.

• 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, and real-world notes.

We (the author and editors) 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.

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. All the programs were tested with CodeWarrior Pro 6 (Macintosh and Windows) and Microsoft Visual C++ 6.0, and most were tested with Borland C++ Command-Line Compiler 5.5, Gnu g++ 2.9.5 running under DOS, and Comeau C/C++ 4.42.5 running under Linux. Only a few programs were affected by compiler non-conformance issues.

C++ offers a lot to the programmer; learn and enjoy!

Note to Instructors

One of the goals of the fourth edition is to provide a book that can be used as either a teach-yourself book or a textbook. Here are some of the features that support using C++ Primer Plus, Fourth Edition as a textbook:

• This book describes generic C++, so it isn't dependent upon a particular implementation.

• The contents track the ISO/ANSI C++ standards committee's work and include discussions of templates, the Standard Template Library, 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 have review questions and programming exercises.

• The book introduces several topics appropriate for computer science courses, including abstract data types, 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.

How This Book Is Organized

This book is divided into 17 chapters and 10 appendixes summarized here.

Chapter 1: Getting Started

This chapter 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. The 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. This chapter discusses these 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 10, 11, 12, 13 and 14. This chapter 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 input and output. Finally, you'll learn some of the ways C++ handles memory allocation, including 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. You'll also 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 this chapter 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.

Chapter 7: Functions—C++'s Programming Modules

Functions are the basic building blocks of C++ programming. This chapter 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

This chapter 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

This chapter discusses putting together multifile programs. It examines your 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 is an instance of a class, such as a variable. This chapter 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 abstract data types (ADTs), such as a stack.

Chapter 11: Working with Classes

In this chapter 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. This chapter 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. This chapter 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 upon the object type. Implementing this kind of behavior necessitates using a new kind of member function called a virtual function. Sometimes abstract base classes are 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. This chapter 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, 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

This chapter 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 or running out of memory. Then you'll learn about RTTI (runtime type information), 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

This chapter 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 Standard Template Library (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.

Chapter 17: Input, Output, and Files

This chapter 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, if there has been a type mismatch on input or if 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, you'll learn how to apply standard I/O methods to read from and write to strings.

Appendix A: Number Bases

This appendix discusses octal, hexadecimal, and binary numbers.

Appendix B: C++ Keywords

This appendix lists C++ keywords.

Appendix C: The ASCII Character Set

This appendix lists the ASCII character set along with decimal, octal, hexadecimal, and binary representations.

Appendix D: Operator Precedence

This appendix lists the C++ operators in order of decreasing precedence.

Appendix E: Other Operators

This appendix summarizes those C++ operators, such as the bitwise operators, not covered in the main body of the text.

Appendix F: The string Template Class

This appendix summarizes string class methods and functions.

Appendix G: The STL Methods and Functions

This appendix summarizes the STL container methods and the general STL algorithm functions.

Appendix H: Selected Readings

This appendix lists some books that can further your understanding of C++.

Appendix I: Converting to ANSI/ISO Standard C++

This appendix provides guidelines for moving from C and older C++ implementations to Standard C++.

Appendix J: Answers to Review Questions

This appendix contains the answers to the review questions posed at the end of each chapter.

ABOUT THE AUTHOR

Stephen Prata teaches 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. Stephen has authored or coauthored over a dozen books for The Waite Group. He wrote The Waite Group's New C Primer Plus, which received the Computer Press Association's 1990 Best How-to Computer Book Award and The Waite Group's C++ Primer Plus, nominated for the Computer Press Association's Best How-to Computer Book Award in 1991.

ACKNOWLEDGMENTS

ACKNOWLEDGMENTS TO THE FOURTH EDITION

Several editors from Pearson and from Sams helped originate and maintain this project, so thanks to Linda Sharp, Karen Wachs, and Laurie McGuire. Thanks, too, to Michael Maddox, Bill Craun, Chris Maunder, and Phillipe Bruno for providing technical review and editing. And thanks again to Michael Maddox and Bill Craun for supplying the material for the Real World Notes. Also, thank you Ron Leichty of Metroworks and Greg Comeau of Comeau Computing for your help with the new C99 features and your noteworthy commitment to customer service.

ACKNOWLEDGMENTS TO THE THIRD EDITION

I'd like to thank the editors from Macmillan Press and Waite Group Press for the roles they played in putting this book together: Tracy Dunkelberger, Susan Walton, and Andrea Rosenberg. Thanks, too, to Russ Jacobs for his content and technical editing. From Metrowerks, I'd like to thank Dave Mark, Alex Harper, and especially Ron Liechty, for their help and cooperation.

ACKNOWLEDGMENTS TO THE SECOND EDITION

I'd like to thank Mitchell Waite and Scott Calamar for supporting a second edition and Joel Fugazzotto and Joanne Miller for guiding the project to completion. Thanks to Michael Marcotty of Metrowerks for dealing with my questions about their beta version CodeWarrior compiler. I'd also like to thank the following instructors for taking the time to give us feedback on the first edition: Jeff Buckwalter, Earl Brynner, Mike Holland, Andy Yao, Larry Sanders, Shahin Momtazi, and Don Stephens. Finally, I wish to thank Heidi Brumbaugh for her helpful content editing of new and revised material.

ACKNOWLEDGMENTS TO THE FIRST EDITION

Many people have contributed to this book. In particular, I wish to thank Mitch Waite for his work in developing, shaping, and reshaping this book, and for reviewing the manuscript. I appreciate Harry Henderson's work in reviewing the last few chapters and in testing programs with the Zortech C++ compiler. Thanks to David Gerrold for reviewing the entire manuscript and for championing the needs of less-experienced readers. Also thanks to Hank Shiffman for testing programs using Sun C++ and to Kent Williams for testing programs with AT&T cfront and with G++. Thanks to Nan Borreson of Borland International for her responsive and cheerful assistance with Turbo C++ and Borland C++. Thank you, Ruth Myers and Christine Bush, for handling the relentless paper flow involved with this kind of project. Finally, thanks to Scott Calamar for keeping everything on track.

TELL US WHAT YOU THINK!

As the reader of this book, you are our most important critic and commentator. We value your opinion and want to know what we're doing right, what we could do better, what areas you'd like to see us publish in, and any other words of wisdom you're willing to pass our way.

As an Associate Publisher for Sams, I welcome your comments. You can e-mail or write me directly to let me know what you did or didn't like about this book—as well as what we can do to make our books stronger.

Please note that I cannot help you with technical problems related to the topic of this book, and that due to the high volume of mail I receive, I might not be able to reply to every message.

When you write, please be sure to include this book's title and author as well as your name and phone or fax number. I will carefully review your comments and share them with the author and editors who worked on the book.