Free Ebook C++ How to Program (3rd Edition), by Harvey M. Deitel, Paul J. Deitel
Also we discuss the books C++ How To Program (3rd Edition), By Harvey M. Deitel, Paul J. Deitel; you may not find the printed publications below. A lot of collections are offered in soft data. It will precisely offer you more benefits. Why? The very first is that you might not have to bring the book all over by fulfilling the bag with this C++ How To Program (3rd Edition), By Harvey M. Deitel, Paul J. Deitel It is for the book remains in soft documents, so you can save it in gizmo. After that, you can open the gadget everywhere as well as read the book effectively. Those are some few advantages that can be got. So, take all advantages of getting this soft data book C++ How To Program (3rd Edition), By Harvey M. Deitel, Paul J. Deitel in this website by downloading and install in web link given.
C++ How to Program (3rd Edition), by Harvey M. Deitel, Paul J. Deitel
Free Ebook C++ How to Program (3rd Edition), by Harvey M. Deitel, Paul J. Deitel
C++ How To Program (3rd Edition), By Harvey M. Deitel, Paul J. Deitel Just how can you change your mind to be a lot more open? There many sources that can assist you to boost your thoughts. It can be from the other encounters as well as tale from some individuals. Schedule C++ How To Program (3rd Edition), By Harvey M. Deitel, Paul J. Deitel is among the trusted resources to get. You could find many publications that we share right here in this site. As well as now, we show you one of the best, the C++ How To Program (3rd Edition), By Harvey M. Deitel, Paul J. Deitel
As we mentioned in the past, the modern technology aids us to constantly acknowledge that life will be consistently much easier. Reading publication C++ How To Program (3rd Edition), By Harvey M. Deitel, Paul J. Deitel habit is also one of the benefits to get today. Why? Innovation can be made use of to offer guide C++ How To Program (3rd Edition), By Harvey M. Deitel, Paul J. Deitel in only soft documents system that could be opened each time you really want and anywhere you require without bringing this C++ How To Program (3rd Edition), By Harvey M. Deitel, Paul J. Deitel prints in your hand.
Those are a few of the benefits to take when obtaining this C++ How To Program (3rd Edition), By Harvey M. Deitel, Paul J. Deitel by on the internet. Yet, exactly how is the way to obtain the soft documents? It's really right for you to visit this web page since you can get the link page to download guide C++ How To Program (3rd Edition), By Harvey M. Deitel, Paul J. Deitel Just click the link supplied in this post and goes downloading. It will not take much time to obtain this e-book C++ How To Program (3rd Edition), By Harvey M. Deitel, Paul J. Deitel, like when you should opt for book establishment.
This is additionally one of the factors by obtaining the soft data of this C++ How To Program (3rd Edition), By Harvey M. Deitel, Paul J. Deitel by online. You could not require more times to invest to go to guide store and also search for them. Occasionally, you likewise do not discover guide C++ How To Program (3rd Edition), By Harvey M. Deitel, Paul J. Deitel that you are browsing for. It will squander the time. However right here, when you visit this page, it will be so simple to obtain and also download guide C++ How To Program (3rd Edition), By Harvey M. Deitel, Paul J. Deitel It will not take several times as we mention before. You can do it while doing something else in your home or perhaps in your office. So easy! So, are you doubt? Merely practice just what we provide here and review C++ How To Program (3rd Edition), By Harvey M. Deitel, Paul J. Deitel just what you love to read!
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.
- Sales Rank: #171268 in Books
- Published on: 2000-08-03
- Original language: English
- Number of items: 1
- Dimensions: 9.25" h x 1.50" w x 7.00" l,
- Binding: Paperback
- 1168 pages
- C++
- How to program
- Third Edition
From the Inside Flap
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:
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.
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:
- 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
About the Author
DR. HARVEY M. DEITEL, CEO of Deitel & Associates, Inc., has 39 years experience in the computing field including extensive industry and academic experience. He is one of the world's leading computer science instructors and seminar presenters. Dr. Deitel earned B.S. and M.S. degrees from the Massachusetts Institute of Technology and a Ph.D. from Boston University. He worked on the pioneering virtual memory operating systems projects at IBM and MIT that developed techniques widely implemented today in systems like UNIX®, Windows NAT,™ OS/2 and Linux. He has 20 years of college teaching experience including earning tenure and serving as the Chairman of the Computer Science Department at Boston College before founding Deitel & Associates, Inc. with Paul J. Deitel. He is author or co-author of several dozen books and multimedia packages and is currently writing five more. With translations published in Japanese, Russian, Spanish, Elementary Chinese, Advanced Chinese, Korean, French, Portuguese, Polish and Italian the Deitels' texts have earned international recognition.
PAUL J. DEITEL, Executive Vice President of Deitel & Associates, Inc., is a graduate of the Massachusetts Institute of Technology's Sloan School of Management where he studied Information Technology. Through Deitel & Associates, Inc. he has delivered Java, C, C++, Internet and World Wide Web courses for industry clients including Compaq, Sun Microsystems, White Sands Missile Range, Rogue Wave Softwave, Computervision, Stratus, Fidelity, Cambridge Technology Partners, Open Environment Corporation, One Wave, Hyperion Software, Lucent Technologies, Adra Systems, Entergy, CableData Systems, NASA at the Kennedy Space Center, the National Severe Storm Center, IBM and many other organizations. He has lectured on C++ and Java for the Boston Chapter of the Association for Computing Machinery, and has taught satellite-based Java courses through a cooperative venture of Deitel & Associates, Inc., Prentice Hall and the Technology Education Network.
The Deitels are co-authors of the best-selling introductory college computer-science programming language textbooks, C How to Program: Third Edition, Java How to Program: Third Edition, Visual Basic 6 How to Program (co-authored with Tem R Nieto) and Internet and World Wide Web How to Program (co-authored with Tem R. Nieto). TheDeitels are also co-authors of the C++ Multimedia Cyber Classroom: Third Edition (the first edition of this was Prentice Hall's first multimedia-based textbook), the Java 2 Multimedia Cyber Classroom: Third Edition, the Visual Basic 6 Multimedia Cyber Classroom and the Internet and World Wide Web Programming Multimedia Cyber Classroom. The Deitels are also co-authors of The Complete C++ Training Course: Third Edition, The Complete Visual Basic 6 Training Course, The Complete Java 2 Training Course: Third Edition and The Complete Internet and World Wide Web Programming Training Course—these products each contain the corresponding How to Program Series textbook and the corresponding Multimedia Cyber Classroom.
Most helpful customer reviews
4 of 4 people found the following review helpful.
I would not recommend this book to ANYONE
By Eric@ Schechter
I was SHOCKED to see positive reviews for this book. I have experience with a wide variety of programming languages and operating systems, all of which I taught myself using only the aid of books and online tutorials. I am currently taking a course at college on C++, and even with the aid of an instructor, I am struggling. This has to be one of the worst programming books ever.
"C++: How to Program" is explicitly geared towards beginners. However, when it introduces aspects of the C++ language, they explain concepts in a manner that could only serve to confuse the reader. For example, a variable is defined as "a location in a computer's memory where a value can be stored for use by a program". While this definition is certainly accurate, it fails to explain how a variable is implemented in a program and what its purpose is. All of the concepts are explained in such a manner; the book describes programming concepts in relation to hardware instead of how they relate to the composition of a program. Both beginners and advanced programmers will find the book confusing. In addition, intermediate-to-expert programmers will want to start doing neat stuff right away.
The excercises are often near impossible to complete using only knowledge gained from the book, and the answers are not provided. I find that one of the most helpful ways of learning a language is from viewing the source code as examples and then breaking down the commands and figuring out how the program was constructed. This book does not allow that. It has a few helpful tips and reference tables, but that's it.
In short, stay away from this book. Trust me. Ignore the other reviews. Buy something from O'Reilly instead; they have yet to disappoint me.
14 of 15 people found the following review helpful.
Inappropriate for its target audience
By Ric Crabbe
I am mostly negative towards this book. I find it to be a serviceable book for teaching C++ to a programmer, but it's title and preface suggest that it is designed as textbook for a first semester college course in Computer Science, so that is how I will consider it. We used it as the textbook for our Introduction to Computer Science course and every professor who used or read it dislikes it greatly. Because of this, we have replaced it with another book for next year. Personally, I find that "C++ How to Program" violates most, if not all, the rules pedagogy.
In my opinion, a good text would: introduce one thing at a time, refer to terminology only after it has been defined, emphasize concepts as well as details, and make few references to material not covered in the text. A good C++ text would teach object oriented style, and not give examples as converted C code, and teach good general (non-C++ specific) principles of algorithm and program design. Although this book routinely violates ALL of these rules, I only have space to to give a couple of examples of each.
On page 79 in chapter 2, in a section on formulating algorithms, static casting is introduced in an example, before the students even fully understand what types are.
On page 176, enum is introduced as part of an example of random number generation. It is then used throughout the book as if it had been a topic of its own.
On p. 476, Dynamic memory is introduced by analogy to C's malloc, a technique that is at best useless to a non-C programmer. Dynamic memory is given a 1 page treatment- something most courses spend 1 to 2 weeks on.
The beginning of section 7.5 on page 471 reads, "Every object has access to its own address through a pointer called this. An object's this pointer is not part of the object itself-i.e., the this pointer is not reflected in the result of a sizeof operation on the object. Rather, the this pointer is passed into the object (by the compiler) as an implicit first argument on every non-static member function call to the object." So instead of giving a REASON for a this pointer, the book focus on a minor attribute, one opaque to a beginning student. In fact, NOWHERE in section 7.5 is there a compelling reason for having a this pointer. Furthermore, static member functions aren't discussed for another 2 sections.
On page 472, the phrase 'cascading function calls' is used but never defined. It is left to the reader to glean what this means from the examples.
On page 482 assert is introduced in the example of static class members, and then used later in the book without further discussion.
On page 486, there is a 2 paragraph section on Container classes and Iterators, which contains no useful information except that they'll be covered in chapter 20 (beginning on page 970).
The above list was made in an afternoon of flipping though the text and is not complete, but rather indicative of how the book was written. These attributes make it unsuitable for an Introduction to Computer Science textbook.
In conclusion, Here are some quotes from the course evalutions last semester from the question, "please comment on the adequacy of the textbook" (25 responses): "completely inappropriate", "terrible"(3), "awful", "inadequate"(2), "complicated", "horrible"(2), "very bad", "tough to follow"(2), "sad", "confusing", "poorly organized", "not understandable", "ridiculously bad", "too busy", "below average", "poor", and "worthless".
2 of 2 people found the following review helpful.
About average or slightly better
By Vitaly Nagy
I have programmed for years in a few languages, although not in C++. In my opinion, this book has obvious advantages and significant disadvantages. It is reasonably detailed and systematic for a textbook, contains enough illustrative pieces of code, and useful listings of typical errors and "good practices". However, in my opinion, the authors are not masters of clear explanation. In many instances they explain basically very simple concepts in an unreasonably complicated way by overloading their illustrations with insignificant additional details that only blur the main point. In some places, such additions involve concepts that are going to be explained only a few chapters later. Quite often I had to consult other books on C++ (some of which are commonly regarded as difficult to read) just to figure out what the authors actually wanted to explain. It is not to say that you will not be able to learn C++ with this book, but this will not be in the most efficient way: you will have to waste a good deal of time and effort unnecessarily. The index also leaves much to be desired. It is a common problem of many contemporary book indexes, which are composed with a computer but without much thinking on the last day before the deadline; in this particular book the poor quality of the index is critical, because readers need cross-references far more often than in well-written textbooks.
C++ How to Program (3rd Edition), by Harvey M. Deitel, Paul J. Deitel PDF
C++ How to Program (3rd Edition), by Harvey M. Deitel, Paul J. Deitel EPub
C++ How to Program (3rd Edition), by Harvey M. Deitel, Paul J. Deitel Doc
C++ How to Program (3rd Edition), by Harvey M. Deitel, Paul J. Deitel iBooks
C++ How to Program (3rd Edition), by Harvey M. Deitel, Paul J. Deitel rtf
C++ How to Program (3rd Edition), by Harvey M. Deitel, Paul J. Deitel Mobipocket
C++ How to Program (3rd Edition), by Harvey M. Deitel, Paul J. Deitel Kindle
