Slashdot Mirror
Practical C++ Programming, Second Edition
Practical C++ Programming is a fairly large book: 549 pages organized into six parts containing 30 chapters and 5 appendixes. The parts are as follows:
- The Basics
- Simple Programming
- Advanced Types and Classes
- Advanced Programming Concepts
- Other Language Features
- Appendixes.
I must start by saying that I like the book -- I think it has value. There are a number of things I really appreciate about the book. There are also some problems that adversely impact one segment of the book's intended audience (more about those later.)
The book discusses all the essential elements of C++. Areas covered include: Class definition, namespaces, scope definition and resolution, operator and function overloading, object memory allocation (i.e. new and delete,) type casting, exceptions, inheritance, templates (including an introduction to the Standard Template Library,) the Input/Output system (including the C I/O library), and pointers. All language operators are discussed (i.e. relational, assignment, etc.) Also covered are language elements that C++ has in common with C. The other areas of instruction (programming style, software development concepts, programming tools) are intertwined with the primary topic throughout the course of the book.
One of the book's strong points is the author's excellent conversational writing style. It's hard to find books that combine good technical information with clear expository writing (O'Reilly seems to publish most of them.) Practical C++ Programming definitely succeeds in this area. The author frequently references his own experience to reinforce concepts on programming style, design and debugging. I found his anecdotes useful and occasionally humorous. The book also contains small sections of text that serve to warn the reader of pitfalls (these are marked with a bear trap icon) and areas where caution should be exercised (marked with bear paw tracks). Also, some of the source code examples contain intentional bugs, which the author explains at the end of each chapter. Diagrams, tables and source code examples are found on almost every page of the book, and these are used to keep the reader engaged with the textual discourse. My favorite diagram is Figure 7-1. "Software life cycle," on page 88; I emphasize with the dinosaur.
The book contains some interesting programming examples. The chapters on operator overloading and floating-point math contain source code illustrating how to deal with the numeric precision problems that plague all computers and computer languages. The chapter on the Standard Template Library contains a program showing how to create and use objects that manage a simple roster for enrollment and grading of students. The book also contains several examples of linked-lists and trees, for the purpose of teaching the reader how to use pointers, and to also show the reader the power and usefulness of the Standard Template Library.
Now to speak about the book's shortcomings. First, although the book does a good job of covering the important C++ topics of classes, inheritance, and templates, I think it falls a bit short in these areas (especially the coverage of inheritance). Also, the terms instantiation, polymorphism and encapsulation are not used in the book. The book could have provided a bit more insight into object-oriented concepts. Also, these areas of the book are sparsely diagrammed. Second, source code errors and typos appear regularly enough to frustrate an inexperienced reader. I also found a couple of diagrams to be confusing. Third, there are occasional misleading statements that a beginner probably won't recognize as such. Because of these problems, I cannot recommend the book to people with no previous programming experience. I'm surprised that these problems made it into a second edition.
I think that despite these problems, the book has value to experienced programmers who want to learn C++. C programmers in particular will have an easier time dealing with the source code errors. Also, I think that the book can be used by beginning programmers in a classroom environment, providing the instructor understands the book's problems and is prepared to guide students around them. The book should be particularly useful when read in conjunction with a good C++ reference guide.
Practical C++ Programming is an ambitious work in its breadth and depth. It covers more areas of software development than other C++ books. It takes an interesting approach that some readers will appreciate and others may not.
I would like to have seen a more detailed and complete explanation of the object-oriented aspects of C++ (including more diagrams). A table showing all functions for Standard Template Library containers would have been nice (the book does make reference to two STL web sites). Some mention of third-party object libraries (such as Rogue Wave, Qt, etc.) and their uses would have been helpful.
The lack of a detailed explanation of inheritance may not be bad. I'm one of those who believe that heavy reliance on inheritance causes serious maintainability problems. However, I think the book should have covered this topic more fully, so the reader would understand this issue.
In summary, Practical C++ Programming is a good book that really shines in some aspects and falls short in others. With some improvement, it could be a great book.
You can purchase Practical C++ Programming, Second Edition from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.
Amazon has it for $4 less and with free shipping!
Practical C++ Programming is dedicated to teaching the reader how to program in the C++ programming language.
No shit, I thought it was the next in the Harry Potter series. My kids are going to be disappointed.
Sorry, it's just that thats the kind of retarded formula-generated opening statement you'd expect from an 8th grader with no interest in the material. Ie; "The Treasure of Pirate Cove is about a treasure in a place called Pirate Cove"
By the way, I love iPods, so mod me up up up!
I don't need no instructions to know how to rock!!!!
All you need for debugging is print statements everywhere. Always works :)
Rus
Cheap UK and US VPS
That's sweet, four goals: 1.) 2.) 3.) 4.) 4.) ;-)
Otherwise, good review! Thank you!
gah I mean "..as Lung Cancer is to Lung"
I'm a retard.
Trolling is a art,
1) Write practical C++ programming book 2) Get it published 3) Have it reviewed on Slashdot 4) ??? 4) Profit!!!
...should, I have decided, always involve the text Accelerated C++, by Koenig and Moo. They have been working with C++ since its inception, down the hall from Stroustrup.
The book takes two relatively new approaches to teaching C++: 1) don't teach C first, and 2) assume that the standard C++ library is there. So, they introduce "Hello, World" using std::string and std::cout, and they keep using std::string without trying to first teach template classes with default template parameters. The resulting intro programs are very clean and simple, easy to follow.
The word "pointer" isn't even mentioned until chapter 9. By that point, they're using strings and vectors to solve useful programs, and since both of those containers manage memory themselves, the user needs to know nothing about dynamic memory management (and thus, pointers) before doing the exercises.
Pointers and user-defined types are introduced, of course, but they don't need to be introduced before showing the reader how to use the basic library features. You don't need to know how an internal combustion engine works before learning how to drive, although going back later and learning what's under the hood will always reward the observant driver.
This approach has gotten rave reviews, and from actual C++ people, not just fluff reviewers. It's the produce of years of teaching C++ courses.
Final note: the book is one of the fantastic "C++ In-Depth" series, of which Stroustrup is the series editor. All are very high quality. One of the series' rules is that the main body of the book can be no more than 300 pages, so "make your point, make it simple, make it clear" rules the day.
You cannot apply a technological solution to a sociological problem. (Edwards' Law)
This was terrible.
My favorite diagram is Figure 7-1. "Software life cycle," on page 88; I emphasize with the dinosaur.
Ok, if I own the book, I'm not going to take the time to read this "review". If I don't own the book I obviously have NO FREAKING clue what figure 7-1 looks like! Also, does "Emphasizing with a dinosour" involve time travel and a shitload of highlighters or what? Or does it mean you hire a dinosour to stand next to you for emphasis? I don't get it...
They who would give up an essential liberty for temporary security, deserve neither liberty nor security
Any new book - and certainly a second edition- on programming (whatever the language) should have a full chapter on security.
http://blog.astyran.sg
As for me...I'm never going to "emphasize" with a dinosaur...I might "empathize" with one (if I met one in a deplorable condition)...who knows?
Now to speak about sentence fragments.
In summary, this review is a good review that really shines in some aspects and falls short in others. With some improvement, it could be a great review. Of course...if you improve anything, it gets better, now doesn't it?
Ack.
Why buy the book when you read it on safari, along with thousands of other books with a free 14 day trial..
The author did a very nice job on Practical C Programming.
But Steve O. shouldn't have let himself be conned into writing the Practical C++ Programming, though. His C bias weighs too heavily and the first edition spent all kinds of time talking about wonderful linked lists with structs just like the C book did.
If you want to learn C++, my suggestions are:
- C++ Distilled by Pohl
- Effective C++ by Scott Meyers
- More Effective C++ by Scott Meyers
- The C++ Standard Library by Josuttis
some other are also good, and of course no guru should be without one of Stroustrup's tomes."Provided by the management for your protection."
... is reviewed here, at the 'net's largest C++-oriented book review site. This review is decidedly in the negative, although Steve Oualline is given a chance to issue a response which is worth reading.
It seems that the 2nd edition of this book may have brought forward some previous problems. I have the first edition but never liked it, never thought it really achieved it's goals.
If you're looking for an uncompromisingly amazing first book on C++, please check out Accelerated C++ by Andrew Koenig and Barbara Moo. This is how I learned C++ and, by using the concepts of teaching core language skills alongside library concepts and best practices in OOP, it truly accelerates the process. Amazing.
Chr0m0Dr0m!C
I remember the first edition of Practical C++ Programming. Readers who wished to get something out of that book should've noticed that it was absolutely necessary to debug the book's programming examples first.
Errata? 'Er sure smella like it!
Chapter VII: How to sign up for unemployment benefits.
Goal 4) teaching proper iteration.
C++ encourages you to avoid solving the problem by trying to introduce abstractions
No it doesnt, it allows you more abstractions that you an use as tools, if they're appropriate. When they're overused or used inappropriately, they detract.
It's like my neighbour who recently bough one of those power spray painter things. He runs around power-painting everything from lawnchairs to his fence - with often terrible results. But he's a guy with a new tool and wants to use it as often as possible, even though it's really only suitable to use in certain niche applications.
Or closer to home, observe the student who just learns recursive techniques. They want to write everything recursively - though it's rarely the best solution and just makes for obscure code. They ubiquitously teach it using factorial as an example, when a for loop is a much better tool.
Such is the way with C++. Not every solution is conducive to an object oriented approach, but it's worth having the tools for the ones that do. The ability to mix and match in large projects is a boon.
If you cant pick the right tools for the right job, then you're a poor craftsman.
I don't need no instructions to know how to rock!!!!
When we can steal it all from SCO...
Also, the terms instantiation, polymorphism and encapsulation are not used in the book.
Seem odd to me that a book that is designed to teach C++ would skimp on the object oriented features of C++. I find polymorphism extremely powerful in many situations. For example, I use it often with bison when writing parsers, and for writing cool Zoo example programs where you call a function MakeSound and it automatically says "Ooo Ooo" for the Monkey, and "Eeeee haaaaa" for the Ass.
Honk if you're horny.
If/when I finally learn C++, it's going to have to be with the help of a book that teach C++ for Windows programming, or C++ for Linux programming. I took a data structures class in college and learned about binary trees and pointers and linked lists and all that stuff, but without being able to write a program that I could imagine actually using, I've had little incentive to remember how to overload the ++ operator.
Are there any good programming books that focus on learning to create GUI's and modern applications? Such as, something that addresses modern concepts like internet connections and DVD drives and database connectivity and such. I don't need to relearn the concepts behind OOP (although a quick overview of syntax would be nice), I want to know how programmers use this stuff, what they create vs. what they have access to (like common dialog boxes), and basically the steps between writing a "sort the list of student records" console app and writing a full-blown application (I know the latter takes a lot of time and code, but I don't know what direction to go in, or how programmers organize all the code).
I really hate signatures, but go to my website.
Without debating the whether C++ is the best choice for beginners, I wish new books on the subject would stop rehashing the same old concepts and methods - not everyone is a C programmer trying to transition to C++. There are a lot of areas that merit greater attention and that will get beginners started on the right foot - and messing with raw pointers isn't one of them.
On top of trying to get the basic OO mindset accross (yes instantiation, polymorphism and encapsulation are big words but the concepts are essential and not that difficult to explain), I'd like to see some more modern and useful concepts explored in depth. For instance:
Just my $0.02 for potential authors out there.
You mean you can calculate factorials without using template meta-programming?
I also recommend a reference card to help people learn C++. When programming in a new language, it is helpful to be able to look up syntax quickly.
This is a plug for the card, but you can download a PDF of the card for free.
http://github.com/gbook/nidb
Back when O'Reilly had a _Practical_C_ book, but no _Practical_C++_ book, I called them and said that they should do one. They rejected my suggestion without pause, saying that their kind of readers didn't think that C++ was better than a pitcher of warm spit. Then some other author came out with a _Practical_C++_ book (now out of print), which wasn't very practical, since it was muchly about the C++ standard, which wasn't a standard then and had barely started to congeal when the book was written. Hence, when O'Reilly finally realized that their old readers had already been educated far beyond their intelligence and that they needed to broaden their appeal, they came out with _Practical_C++_Programming_. You can't copyright a title, but at least it cuts down on the confusion. Now it's gone multiple editions. It's pretty good, but nothing is worse than being ahead of your time before the world is ready.
>The author encourages the reader to use a computer to enter, run and debug the book's programming examples. I concur with this advice, though it isn't absolutely necessary.
This is something that novice programmers are well advised to listen to. I constantly am asked by junior programmers 'What happens when I do x', where x is something simple, like try to print out an array.
Half the time, the problem can be answered by simply trying it. And the other half of the time, you end up with a better question (I want to print out the values of an array, but print @array didn't work. What's the trick?) (In perl, see 'perldoc -f join'. That's not my point, but I don't want to leave you hanging!)
And even better, learning the value of experimentation makes you a better programmer, and a much more pleasant junior employee. Instead of spending all your time asking a series of questions, you try a whole bunch of things. By actually stopping to think about the problem, which this approach forces you to do, you end up learning a lot more, and sometimes the failed efforts are exactly what you need later. And if you're stumped, you still end up looking smarter, because you at least tried some approaches. And more often than not, it's easier to learn the answer if you've taken the time to struggle with and really learn the problem you're trying to solve, and remember the answer next time.
I think this is one of the unheralded keys to becoming a good professional programmer.
Caveat: This works a lot better in some development environments than others. I do most of my work in perl, which is ideally suited to this rapid prototype approach. In environments with long compile times, it's more tedious. This is thankfully decreasingly true, with faster machines making the hours-long compiles a historical problem, so take advantage of it, learn to experiment, and reap the rewards.
-- Kate
I find that the people who advocate C over C++ have really done nothing but use C++ as a glorified C. Even the people who claim that they are using C++ properly with high falutin' OO methodologies are still writing code that can be transformed into C with a minimum of effort. Code written generically with C++ templates cannot trivially (in a precisely definable sense) be transformed into C code and hence can be used to efficiently solve problems that are a nightmare in C.
Doesn't it make you feel good to know that our freedoms are protected by politicans, lawyers and journalists.
Instead of comparing just B&N vs. Amazon all of the time, why not use the book shopping bots? (Amazon and B&N are not the cheapest books every time you buy a book (they may be in this case (I checked), but in many cases, the others are much cheaper)! The bots search a lot of the book stores and rank the prices (including handling/shipping), present opportunities for discounts, and even point out the ability for finding books which may be out of print but can be purchased used.
Think of this as a book equivalent to PriceWatch
(these links were tested in 'preview' mode before posting.
BookPool
AddAll
BestBookBuys
I mean, if you're going the 'don't need to understand 'C', pointer-free, high-level only route, use something interesting and easy to use like Perl, (heaven forbid) VB, Java, or Python.
To me, the STL was like putting lipstick on a garbage can. It may look prettier now but I'm still never going to kiss it. It's still something you have to wrangle, bang around and not look at when you don't have to.
Does it hurt to hear them lying? Was this the only world you had?
He probably meant to type 'empathize', though I agree with your criticism.
... OK ... so, which was it? Does it do a good job or does it fall short?
I was also did a double take with this remark:
First, although the book does a good job of covering the important C++ topics of classes, inheritance, and templates, I think it falls a bit short in these areas (especially the coverage of inheritance).
Um
The little guy just ain't getting it, is he?
How many "How to program in C++" books to we need?
More power to 'em, I guess. It just seems to me that the language has been around for awhile, has aged gracefully, and has an entire library's worth of books written for it.
I suppose it's good to update every once in awhile, but this book doesn't seem to have anything new (based on the review). I'll stick to the 4 or 5 I have, thanks.
My sig sucks.
visual studio's IDE (well if you're a purist you can not use the visual part of VC++) allows you to debug your functions and watch your memory allocation [stack/heap] and registers as you step through. I think this is what you want.
I don't mean to bag on Steve Oulline. Maybe in person he's a great guy and gets tons of chicks...
But I happen to have his "Practical C Programming", and i discovered after the fact that it gets lots of thumbs down from both comp.lang.c and #c on freenode.
I've also got some personal beefs with it, in that there are many places where it is either implied or specifically stated that C is merely a stepping stone to C++.
"Get into the habit of pre-fixing your increments and decrements (i.e. ++i, --i, as opposed to i++ and i--) because it will make your transition easier to C++"
"A lot of the concepts that are involved with structures in C will become relevant when you move up to Object Oriented Programming C++"
"The next logical step for C programmers is to learn C++"
Maybe some of these statements can be benign or true for most, but me personally, i don't want to learn C++. I think the same end result could be sought with C than with C++.
Just MHO.
Karma be damned.
do() || do_not();
You know you really think that most people must have nothing to do. Whenever they get a new tool, whether circular saw, programming language or exotic spice, they just have to use it everywhere. I guess that's partially just human nature: it's fun to experiment with something new. But they must really not have any serious need for it or they'd just use it for what they needed.
In my experience I'd say more than 50% of all tool users use them for fun/kicks, not because they have a pressing task to do with them.
I know this is way off point. I guess I just don't have anything important to do and slashdot is a fun tool............
I agree that C++ nightmares come when people misuse its features. And vice versa; triumphs occur when people use the features well.
But that's the thing - it's too easy to misuse C++'s features. YES, a well-trained, experienced C++ programmer can work wonders, BUT that's like 1% or less of the programming population!
C++ made a lot of design tradeoffs (e.g. it does not automatically handle allocated space well without extreme programmer care) connected to computer technology EONs ago. It's a really weird, funky balance - it tries to be high level, but also tries not to do anything for you else risk wasting CPU cycles for some corner-case performance hungry situation.
Like a lot of people, I find myself either using plain old C for things that need it (kernel drivers) and Python/Java for anything complicated.
Does it hurt to hear them lying? Was this the only world you had?
Who told you that the abstraction was going to solve every problem for you? Did you think the C++ Pixies were going to arrive and write your code for you? ;-)
What C++ (and other OO languages) give you is an abstraction which may make your solution easier to design/code. If this abstraction doesn't match the needs of your problem, use a different one. C++ and other OO languages are perfect for GUI-type stuff, but they suck big-time for writing embedded software. The best hammer is a damn poor screwdriver, and all that.
If you insist on only using C for GUI applications, good luck - I did some substantial GUI work in X (X11R5) using C about 10 years ago, and trying to use C to emulate object-orientation is one of the abiding horrors in my memory. Equally we had a uni project to design a real-time position controller using C++, and I'm scarred by those memories too.
What sets the computing industry back is some twonk assuming that a particular methodology (structured design, OO, etc) is a magic bullet. That sucks, bcos it isn't. What also sets the industry back is some other twonk acting Luddite and saying "the old way is the One True Way" (*cough*).
Grab.
...and in the next edition, the book will have the additional goals of 5) Introduce the reader to US Copyright law 6) How to stay out of prison after violating the DMCA and 7) Learn how to pick the best copyright lawyer to defend against SCO lawsuits.
I think in this case, I'd just head on down to the library and flip through their C++ books until I found one I liked. Or grab a copy of Deitel & Deitel since that seems to be a pretty standard introductory textbook for programming classes.
The sending of this message pretty much inconveniences everyone involved.
Can you believe that this kind of code could make it in here? It's the kind of thing that developers would call "ugly."
I really hate signatures, but go to my website.
"Second, source code errors and typos appear regularly enough to frustrate an inexperienced reader."
but earlier you said
"4) The author encourages the reader to use a computer to enter, run and debug the book's programming examples"
Everyone that's ever had a programming class knows all of those errors were intentionaly put there to test you. At least that's what my profs always told me when they gave the class buggy code.
Some problems with this review:
1. Where's the basic information about this book? Author, publisher, ISBN, list price, etc. None of these are mentioned in the review (yes, there's a link to B&N, but, c'mon).
2. Sequencing is an essential aspect of a technical book review. In what order does the author address the topics? Are there many forward references? Does the author march through the topics one at a time or is the subject matter gradually explored, step-wise? A Table of Contents listing (instead of the simplistic 6 parts) would be nice, at a minimum.
Some problems with this book:
1. Having found the TOC on O'Reilly's website (http://www.oreilly.com/catalog/cplus2/toc.html), it's clear that this book features the Bad Old Style of C++ pedagogy: namely, teach C first. The author tackles arrays before std::vector, structs (and unions!) before classes, C-style linked lists before std::list, switch statements before virtual functions, and macros before templates. The new approach to teaching C++ is to give the user familiarity with the powerful utilities of the standard library, so that useful programs can be written right off the bat, and then to explore the dizzying array of language constructs which make the standard library what it is. I encourage those new to C++ to check out Accelerated C++ as an alternative introduction to C++.
2. The reviewer points out that there are many code errors in the book. This is unacceptable, especially for a beginning book. A small number of obvious typos can be forgiven, but anything more than that should consign a tech book -- again, especially an introductory book, where the audience has little experience for dealing with errors -- to the circular file.
While I love many of O'Reilly's offerings, their coverage of C++ has always seemed spotty and outdated. I encourage anyone trying to learn C++ to check out the C++ In Depth series published by Addison-Wesley, starting with Accelerated C++ and Essential C++.
Jon
You youngins and your fancy schmancy computer thingies. Back in my days we didn't have no fancy "computers" and we were grateful! We all did are programming using pseudocode. We never had to deal with memory or speed restrictions! The sky was the limit! Things have gone downhill since they made the switch to those fancy computers. So show some respect, sonny!
Yes sir, those were the good ol' days.
void main? No points.
? Not part of Standard C++, which has instead.
The rest of the card doesn't look much better. The reserved words are listed and the card notes that they can't be used as identifiers, but it doesn't mention that there are other reserved identifiers.
The description of while(x) says that x must be an expression, but for a long long time C++ has allowed a variable declaration at this point, and such use is idiomatic.
The example of operator overloading is far from ideal: the argument is idiomatically passed by const reference, not by value, and for operator- it's normal to copy and then subtract the rhs, rather than the more C-inspired code shown.
This card might be helpful in its free version, but if you pay money you probably want something that's teaching correct/good C++.
Maybe with an update the card would be a good thing. Visually it's not unappealing and some thought has clearly gone into it: it's just that it has not been written by a C++ expert.
"Another problem with a debugger is if your app is split into DLL's: how do you debug into a DLL if that is where it is choking?"
Uh, use Visual C++? All my apps are split into DLLs. When I'm stepping through something in the debugger, I neither notice nor generally care that I've crossed a DLL boundary. (Except when I'm tracking a memory leak, in which case I notice on purpose...) Most of the time I'm setting a breakpoint deep in the guts of some dll and letting the rest just run until it gets there. Seriously, what's suposed to be the problem with debugging into dlls?
Not sure what you mean by running a DLL "stand-alone". Most dlls don't stand alone. the debugger will tell you everyting passed in to a dll function, at which point it shouldn't matter what called it; ocasionally I write a stupid exe to call one function I think is a problem, but just to speed the debug cycle.