C++ How to Program, 3rd Edition

About

Features

• NEW - An optional case study focusing on object-oriented design using the UML—Illustrates the entire process of object-oriented design from conception and design to programming and implementation. This case study is introduced in Chapter 1 and built upon in the next eight chapters.

  • Introduces readers to the UML and key notational schemes that they will encounter in the real world. Ex.___

• NEW - CD-ROM with each text.

  • Includes Microsoft® Visual C++™ 6.0 Introductory Edition software, source code for all the book's examples and hyperlinks to C++ demos and Internet resources. Ex.___

• NEW - Now in full-color.

  • Program listings now include syntax coloring of key code, which helps students to interpret the code they examine. Ex.___

• Signature “Live Code Approach”—Language features are presented in the context of a wide variety of complete working C++ programs. Features more than 10,000 lines of code in approximately 250 complete working programs.

  • Enables readers to confirm that programs run as expected. Readers can also manipulate the code from the CD-ROM in the back of the book or from the book's Companion Website (www.prenhall.com/deitel). Ex.___

• Outstanding, consistent and applied pedagogy—Icons throughout identify Software Engineering Observations; Good Programming Practices; Common Programming Errors; Portability Tips; Performance, Testing and Debugging tips.

  • Provides hundreds of valuable programming tips and facilitates learning. Ex.___

• Extensive set of interesting exercises and substantial projects—More than any other C++ book on the market.

  • Readers can apply what they've learned in each chapter. Ex.___

• Substantial treatment of the standard template library included—Covers STL containers, container adapters, algorithms, iterators and resources on the Web.

  • Students learn how to use this time-saving feature. Ex.___

• Definitive sections on C++ stream-oriented input/output and file processing.

• Text adheres to the latest draft of the ANSI C++ standards.

  • Provides the student with the most up-to-date coverage. Ex.___

• Also available with the award-winning Multimedia Cyber Classroom CD-ROM —In The Complete C++ Training Course, Student Edition, 3/E.

  • Includes many hours of detailed, expert audio descriptions of “live code,” hundreds of self-review questions (half with answers), hundreds of programming exercises (half with answers), hundreds of tips that are marked with icons and show how to write C++ code that's portable, reusable, and optimized for performance; and full-text searching and hyperlinking. Ex.___

Description

The complete, authoritative introduction to C++, OOD and the UML™

These are exciting times in the C++ community with the acceptance of the new ANSI/ISO C++ standard and with the involvement of the Object Management Group™ (OMG™) in the specification of the Unified Modeling Language (UML). This Third Edition of the world's most widely used C++ textbook carefully explains C++'s extraordinary capabilities—including the latest additions to the language and the new ANSI/ISO C++ standard library.

Dr. Harvey M. Deitel and Paul J. Deitel are the principals of Deitel & Associates, Inc., the internationally-recognized corporate training and content-creation organization specializing in C++, Java™, Internet, World Wide Web and object technologies. The Deitels are also the authors of the world's #1 introductory Java, C and Internet programming textbooks—Java How to Program, C How to Program and Internet & World Wide Web How to Program.

In C++ How to Program: Third Edition, the Deitels introduce the fundamentals of object-oriented programming and generic programming in C++. Key topics include:

• Classes, objects and encapsulation
• Inheritance and polymorphism
• Standard Template Library (STL)
• Object-oriented design with the UML
• Arrays and strings as full-fledged objects
• Namespaces and runtime type identification

C++ How to Program helps students build real-world C++ applications. It includes:

• Hundreds of "live-code" programs with screen captures that show exact outputs
• Extensive exercises (many with answers) accompanying every chapter
• Hundreds of tips, recommended practices, and cautions all marked with icons

C++ How to Program is the centerpiece of a complete family of resources for teaching and learning C++, including Web sites (www.deitel.com and www.prenhall.com/deitel) with the book's source-code examples and other information for faculty, students and professional programmers; an optional interactive CD-ROM (C++ Multimedia Cyber Classroom: Third Edition) with solutions to about half the exercises in C++ How to Program, interactivity features—such as thousands of hyperlinks and audio walkthroughs of the hundreds of code examples in C++ How to Program—and e-mail access to the authors at deitel@deitel.com

For information on worldwide corporate on-site seminars and Web-based training offered by Deitel & Associates, Inc., visit: www.deitel.com

Sample Content

Table of Contents

(NOTE: Each chapter begins with Objectives, an Outline, and an Introduction and ends with a Summary, Terminology, Common Programming Errors, Good Programming Practices, Performance Tips, Portability Tips, Software Engineering Observations, Self-Review Exercises, Self-Review Exercise Answers, and Exercises.)

 1. Introduction to Computers and C++ Programming.


 2. Control Structures.


 3. Functions.


 4. Arrays.


 5. Pointers and Strings.


 6. Classes and Data Abstraction.


 7. Classes: Part II.


 8. Operator Overloading.


 9. Inheritance.


10. Virtual Functions and Polymorphism.


11. C++ Stream Input/Output.


12. Templates.


13. Exception Handling.


14. File Processing.


15. Data Structures.


16. Bits, Characters, Strings and Structures.


17. The Preprocessor.


18. C Legacy Code Topics.


19. Class String and String Stream Processing.


20. Standard Template Library (STL).


21. Standard C++ Language Additions.


Appendix A: Operator Precedence Chart.


Appendix B: ASCII Character Set.


Appendix C: Number Systems.


Appendix D: C++ Internet and Web Resources.


Bibliography.


Index.

Preface

Preface

C++ How to Program: Third Edition

We performed an extensive review process on this Third Edition that led to thousands of polishing changes. We also completely updated the programs in the text to conform to the C++ standard's use of namespaces.

The major new feature of this Third Edition is a complete, fully-implemented case study on object-oriented design using the Unified Modeling Language^™ (UML). We felt that a commitment to larger-scale object-oriented design projects is something that has been lacking in introductory programming textbooks. This optional case study is highly recommend because it will considerably enhance the students' experience in a first-year university programming sequence. This case study provides students with an opportunity to immerse themselves in a 1000+ line C++ program that was carefully scrutinized by a team of distinguished industry and academic reviewers.

In the previous editions of this book, we included special "Thinking About Objects" sections at the ends of Chapters 1 through 7. These sections walked the student through the steps needed to design the software simulator for an elevator system. We asked the student to complete these steps and to implement their design in C++. For C++ How to Program: Third Edition, we have completely remodeled this case study. At the ends of Chapters 1 through 7 and the end of Chapter 9, we use the "Thinking About Objects" sections to present a carefully paced introduction to object-oriented design using the UML. The UML is now the most widely used graphical representation scheme for modeling object-oriented systems. The UML is a complex, feature-rich graphical language. In our "Thinking About Objects" sections, we present a concise, simplified subset of these features. We then use this subset to guide the reader through a first design experience with the UML intended for the novice object-oriented designer/programmer. We present this case study in a fully solved format. This is not an exercise; rather, it is an end-to-end learning experience that concludes with a detailed walkthrough of the C++ code.

In each of the first five chapters we concentrate on the "conventional" methodology of structured programming, because the objects we will build will be composed, in part, of structured-program pieces. We then end each chapter with a "Thinking About Objects" section in which we present an introduction to object orientation using the Unified Modeling Language (UML). Our goal in these "Thinking About Objects" sections is to help students develop an object-oriented way of thinking, so they can immediately put to use the object-oriented programming concepts that they begin learning in Chapter 6. In the first of these sections at the end of Chapter 1, we introduce basic concepts (i.e., "object think") and terminology (i.e., "object speak"). In the optional "Thinking About Objects" sections at the ends of Chapters 2 through 5 we consider more substantial issues as we attack a challenging problem with the techniques of object-oriented design (OOD). We analyze a typical problem statement that requires a system to be built, determine the objects needed to implement that system, determine the attributes the objects will need to have, determine the behaviors these objects will need to exhibit and specify how the objects will need to interact with one another to meet the system requirements. We do all this even before we discuss how to write object-oriented C++ programs. In the "Thinking About Objects" sections at the ends of Chapters 6, 7 and 9, we discuss a C++ implementation of the object-oriented system we designed in the earlier chapters.

This case study is significantly larger than any other project attempted in the book. We feel that the student gains significant experience by following this complete design and implementation process. This project forced us to incorporate topics that we do not discuss in any other section of the book, including object interaction, an in-depth discussion of handles, the philosophy of using references vs. pointers and the use of forward declarations to avoid the circular include problem. This case study will help prepare students for the kinds of substantial projects encountered in industry.

"Thinking About Objects" Sections
In Chapter 2, we begin the first phase of an object-oriented design (OOD) for the elevator simulator—identifying the classes needed to implement the simulator. We also introduce the UML use case, class and object diagrams and the concepts of associations, multiplicity, composition, roles and links.

In Chapter 3, we determine many of the class attributes needed to implement the elevator simulator. We also introduce the UML statechart and activity diagrams and the concepts of events and actions as they relate to these diagrams.

In Chapter 4, we determine many of the operations (behaviors) of the classes in the elevator simulation. We also introduce the UML sequence diagram and the concept of messages sent between objects.

In Chapter 5, we determine many of the collaborations (interactions between objects in the system) needed to implement the elevator system and represent these collaborations using the UML collaboration diagram. We also include a bibliography and a list of Internet and World Wide Web resources that contain the UML 1.3 specifications and other reference materials, general resources, tutorials, FAQs, articles, whitepapers and software.

In Chapter 6, we use the UML class diagram developed in previous sections to outline the C++ header files that define our classes. We also introduce the concept of handles to objects in the system and we begin to study how to implement handles in C++.

In Chapter 7, we present a complete elevator simulator C++ program (approximately 1000 lines of code) and a detailed code walkthrough. The code follows directly from the UML-based design created in previous sections and employs our good programming practices, including the use of static and const data members and functions. We also discuss dynamic-memory allocation, composition and object interaction via handles and how to use forward declarations to avoid the circular include problem.

In Chapter 9, we update the elevator simulation design and implementation to incorporate inheritance. We also suggest further modifications so that the student may then design and implement, using the tools presented in the previous sections.

We sincerely hope that this newly updated elevator simulation case study provides a challenging and meaningful experience for both students and instructors. We employ a carefully developed, incremental object-oriented process to produce a UML-based design for our elevator simulator. From this design, we produce a substantial working C++ implementation using key programming notions, including classes, objects, encapsulation, visibility, composition and inheritance. We would be most grateful if you would take a moment to send your comments, criticisms and suggestions for improving this case study to us at deitel@deitel.com.

About this Book

C++ How to Program contains a rich collection of examples, exercises and projects drawn from many fields to provide the student with a chance to solve interesting real-world problems. The book concentrates on the principles of good software engineering and stresses program clarity. We avoid arcane terminology and syntax specifications in favor of teaching by example.

This book is written by educators who spend most of their time teaching and writing about edge-of-the-practice programming languages.

The text places a strong emphasis on pedagogy. For example, virtually every new concept of either C++ or object-oriented programming is presented in the context of a complete, working C++ program immediately followed by a window showing the program's output. Reading these programs is much like entering and running them on a computer. We call this our "live-code approach."

Among the other pedagogical devices in the text are a set of Objectives and an Outline at the beginning of every chapter; Common Programming Errors, Good Programming Practices, Performance Tips, Portability Tips, Software Engineering Observations and Testing and Debugging Tips enumerated in, and summarized at, the end of each chapter; comprehensive bullet-list-style Summary and alphabetized Terminology sections in each chapter; Self-Review Exercises and Answers in each chapter; and the richest collection of Exercises in any C++ book.

The exercises range from simple recall questions to lengthy programming problems to major projects. Instructors requiring substantial term projects will find many appropriate problems listed in the exercises for Chapters 3 through 21. We have put a great deal of effort into the exercises to enhance the value of this course for the student.

In writing this book, we have used a variety of C++ compilers. For the most part, the programs in the text will work on all ANSI/ISO compilers.

This text is based on the C++ programming language as developed by Accredited Standards Committee X3, Information Technology and its Technical Committee X3J16, Programming Language C++, respectively. This language was approved by the International Standards Organization (ISO). For further details, contact:

X3 Secretariat
1250 Eye Street NW
Washington DC 20005

The serious programmer should read these documents carefully and reference them regularly. These documents are not tutorials. Rather they define C++ and C with the extraordinary level of precision that compiler implementors and "heavy-duty" developers demand.

We have carefully audited our presentation against these documents. Our book is intended to be used at the introductory and intermediate levels. We have not attempted to cover every feature discussed in these comprehensive documents.

Objectives
Each chapter begins with a statement of objectives. This tells the student what to expect and gives the student an opportunity, after reading the chapter, to determine if he or she has met these objectives. It is a confidence builder and a source of positive reinforcement.

Quotations
The learning objectives are followed by a series of quotations. Some are humorous, some are philosophical and some offer interesting insights. Our students enjoy relating the quotations to the chapter material. You may appreciate some of the quotations more after reading the chapters.

Outline
The chapter outline helps the student approach the material in top-down fashion. This, too, helps students anticipate what is to come and set a comfortable and effective learning pace.

Sections
Each chapter is organized into small sections that address key C++ topics.

13,741 Lines of Syntax-Colored Code in 268 Example Programs (with Program Outputs)
We present C++ features in the context of complete, working C++ programs; each program is immediately followed by a window containing the outputs produced when the program is run—we call this our "live-code approach." This enables the student to confirm that the programs run as expected. Relating outputs back to the program statements that produce those outputs is an excellent way to learn and to reinforce concepts. Our programs exercise the diverse features of C++. Reading the book carefully is much like entering and running these programs on a computer. The code is "syntax colored" with C++ keywords, comments and other program text each appearing in different colors. This makes it much easier to read the code—students will especially appreciate the syntax coloring when they read the many more substantial programs we present.

469 Illustrations/Figures
An abundance of colorized charts and line drawings is included. The discussion of control structures in Chapter 2 features carefully drawn flowcharts. (Note: We do not teach the use of flowcharting as a program development tool, but we do use a brief flowchart-oriented presentation to specify the precise operation of C++'s control structures.) Chapter 15, "Data Structures," uses colorized line drawings to illustrate the creation and maintenance of linked lists, queues, stacks and binary trees. The remainder of the book is abundantly illustrated.,

625 Programming Tips We have included six design elements to help students focus on important aspects of program development, testing and debugging, performance and portability. We highlight hundreds of these tips in the form of Good Programming Practices, Common Programming Errors, Performance Tips, Portability Tips, Software Engineering Observations and Testing and Debugging Tips. These tips and practices represent the best we have been able to glean from almost six decades (combined) of programming and teaching experience. One of our students—a mathematics major—told us recently that she feels this approach is somewhat like the highlighting of axioms, theorems and corollaries in mathematics books; it provides a basis on which to build good software.

• 112 Good Programming Practices: Good Programming Practices are highlighted in the text. They call the student's attention to techniques that help produce better programs. When we teach introductory courses to nonprogrammers, we state that the "buzzword" of each course is "clarity," and we tell the students that we will highlight (in these Good Programming Practices) techniques for writing programs that are clearer, more understandable and more maintainable.
• 216 Common Programming Errors: Students learning a language—especially in their first programming course—tend to make certain kinds of errors frequently. Focusing on these Common Programming Errors helps students avoid making the same errors. It also helps reduce long lines outside instructors' offices during office hours!
• 87 Performance Tips: In our experience, teaching students to write clear and understandable programs is by far the most important goal for a first programming course. But students want to write the programs that run the fastest, use the least memory, require the smallest number of keystrokes, or dazzle in other nifty ways. Students really care about performance. They want to know what they can do to "turbo charge" their programs. So we have include Performance Tips to highlight opportunities for improving program performance.
• 37 Portability Tips: Software development is a complex and expensive activity. Organizations that develop software must often produce versions customized to a variety of computers and operating systems. So there is a strong emphasis today on portability, i.e., on producing software that will run on a variety of computer systems with few, if any, changes. Many people tout C++ as an appropriate language for developing portable software, especially because of C++'s close relationship to ANSI/ISO C and the fact that ANSI/ISO C++ is the global C++ standard. Some people assume that if they implement an application in C++, the application will automatically be portable. This is simply not the case. Achieving portability requires careful and cautious design. There are many pitfalls. We include numerous Portability Tips to help students write portable code.
• 146 Software Engineering Observations: The object-oriented programming paradigm requires a complete rethinking about the way we build software systems. C++ is an effective language for performing good software engineering. The Software Engineering Observations highlight techniques, architectural issues and design issues, etc. that affect the architecture and construction of software systems, especially large-scale systems. Much of what the student learns here will be useful in upper-level courses and in industry as the Student begins to work with large, complex real-world systems.
• 27 Testing and Debugging Tips: This "tip type" may be misnamed. When we decided to incorporate Testing and Debugging Tips into this new edition, we thought these tips would be suggestions for testing programs to expose bugs and suggestions for removing those bugs. In fact, most of these tips tend to be observations about capabilities and features of C++ that prevent bugs from getting into programs in the first place.

Summary
Each chapter ends with additional pedagogical devices. We present an extensive, bulletlist-style Summary in every chapter. This helps the student review and reinforce key concepts. There is an average of 37 summary bullets per chapter.

Terminology
We include a Terminology section with an alphabetized list of the important terms defined in the chapter—again, further reinforcement. There is an average of 72 terms per chapter.

Summary of Tips, Practices and Errors
We collect and list from the chapter the Good Programming Practices, Common Programming Errors, Performance Tips, Portability Tips, Software Engineering Observations and Testing and Debugging Tips.

554 Self-Review Exercises and Answers (Count Includes Separate Parts)
Extensive Self-Review Exercises and Answers to Self-Review Exercises are included for self study. This gives the student a chance to build confidence with the material and prepare to attempt the regular exercises.

877 Exercises (Count Includes Separate Parts; 1431 Total Exercises)
Each chapter concludes with a substantial set of exercises including simple recall of important terminology and concepts; writing individual C++ statements; writing small portions of C++ functions and classes; writing complete C++ functions, classes and programs; and writing major term projects. The large number of exercises enables instructors to tailor their courses to the unique needs of their audiences and to vary course assignments each semester. Instructors can use these exercises to form homework assignments, short quizzes and major examinations.

550 page Instructor's Manual with Solutions to the Exercises
The solutions for the exercises are included on the Instructor's CD and on the disks available only to instructors through their Prentice Hall representatives. NOTE: Please do not write to us requesting the instructor's CD. Distribution of this CD is limited strictly to college professors teaching from the book. Instructors may obtain the solutions manual only from their Prentice Hall representatives. Solutions to approximately half of the exercises are included on the C++ Multimedia Cyber Classroom: Third Edition CD (available September 2000; please see the last few pages of this book for ordering instructions).

4523 Index Entries (Total of 7653 Counting Multiple References)
We have included an extensive Index at the back of the book. This helps the student find any term or concept by keyword. The Index is useful to people reading the book for the first time and is especially useful to practicing programmers who use the book as a reference. Most of the terms in the Terminology sections appear in the Index (along with many more index items from each chapter). Thus, the student can use the Index in conjunction with the Terminology sections to be sure he or she has covered the key material of each chapter.

Updates

Submit Errata