This specific ISBN edition is currently not available.View all copies of this ISBN edition:
Introduces the fundamentals of object-oriented programming and generic programming in C++. Topics include classes, objects, and encapsulation, inheritance and polymorphism, and object-oriented design with the UML. Previous edition: c1998. Softcover.
"synopsis" may belong to another edition of this title.
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. 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:
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.
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.
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.
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.
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.
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 parad...From the Back Cover:
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:
C++ How to Program helps students build real-world C++ applications. It includes:
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 email@example.com
For information on worldwide corporate on-site seminars and Web-based training offered by Deitel & Associates, Inc., visit: www.deitel.com
"About this title" may belong to another edition of this title.
Book Description Prentice Hall, 2000. Paperback. Condition: New. 3. Seller Inventory # DADAX0130895717
Book Description Prentice Hall, 2000. Paperback. Condition: New. book. Seller Inventory # M0130895717
Book Description Prentice Hall, 2000. Paperback. Condition: New. Never used!. Seller Inventory # P110130895717
Book Description Prentice Hall, 2000. Paperback. Condition: New. Brand New!. Seller Inventory # VIB0130895717
Book Description Prentice-Hall. Condition: New. pp. 1168. Seller Inventory # 7578631
Book Description Prentice Hall, 2000. Paperback. Condition: New. Seller Inventory # KSK-9780130895714
Book Description Prentice Hall, 2000. Paperback. Condition: New. Seller Inventory # KSK-9780130895714