Customer Reviews

C++ FAQs (2nd Edition)

5 star:		(17)
4 star:		(5)
3 star:		(3)
2 star:		(2)
1 star:		(1)

 

 

This is the first book I pick up when I need an answer.

The entire book is a series of FAQs, organized extremely well. Each topic has its own chapter. Within a chapter, the questions progress from general to specific, often in the same order that they pop into my mind. Each question is followed by a cut-to-the-chase 1-sentence answer, followed by a more detailed explanation. Finding your question in the book is facilitated by a table of contents that lists each FAQ, and a detailed index.

I also like the editorializing. ("Arrays are evil.") One reason I find C++ baffling is that there are so many ways to do something. The authors pick a way and tell you why it is better than the alternatives. That's information I can use.

As a bonus, there's a chapter on understanding management's perspective. For example, when you're trying to convince management to adopt the object-oriented paradigm, "Show why it's relevant... don't use the 'it will keep the developers happy' approach ... most managers think that they are the people who need to be kept happy ...".

Incidentally, when I find the time, I plan to systematically read the book start to finish, just to fill in gaps in my knowledge. It is entertaining enough that I'm actually looking forward to it.

This is a 'much expanded' version of the famous on-line C++ FAQ which promises much more detail and material. Since I am trying to constantly prove that I do know C++ well, I picked this book during my C++ book buying craze. I did read this book and while it doesn't make any serious mistakes related to C++, I just don't feel this book is relevant.

First of all, the authors have clearly not given any thought to what their target audience would be. The level of presentation swings wildly from absolute basics (What is a class?) to fairly advanced subjects. Just as I found too many elementary questions in the book, someone less prepared would be surprised by a number of "advanced" topics. While this is understandable for a free on-line document, it doesn't render well in a rather costly book. Same applies to the annoying 'New!' labels marking new or updated topics. Again, this makes sense in a frequently changing on-line document, but it looks ridiculous in a printed book.

The C++ design and coding style presented feels fairly solid and in that sense I can recommend this book to anyone without fearing that it would teach him something objectionable. The authors do their best to stress the importance of interpretation of a base class as a contract and this is a good thing. However, there are still some questionable statements that I don't agree with:

- In 9.02 the authors suggest using exceptions for error handling - all error handling. Whether it is a good thing or not is still a hotly debated topic and I would suggest to at least present the disadvantages of such an approach and alternative methods.

- The authors routinely check the new operator result for NULL, which not only doesn't make much sense (per ANSI C++, new() doesn't return NULL if it cannot create an object) but also teaches a fairly bad technique.

Now, imagine my surprise when, while reading a book on C++ (presumably C++ language), I ended up with a chapter on COM and then another one on CORBA. No matter how related this material may feel, it is still not C++-specific. This sudden addition feels like book padding and that aforementioned 'additional material' that was supposed to sway the users of the free version to purchase the printed book. Well, it seems to have had a completely opposite effect upon me.

I fully understand the authors' desire to be rewarded for their creation (that is, the on-line C++ FAQ). However, this is not an excuse to produce a book which is essentially a rehashed version of the free material diluted with barely relevant topics. Bottom line: read the free on-line version and spend your money either on Stroustrup's "The C++ programming Language" (if you are a novice) or on Myers's "Effective C++" dilogy.

I always like to start any review of a technical book with the table of contents, and see no reason to break with that practice here:

I Preliminaries

Introduction - Basic C++ Syntax and Semantics - Understanding the Management Perspective- The Architectural Perspective

II Object-Oriented Design

Object-Oriented Fundamentals - Specification of Observable Behavior - Proper Inheritance - Detecting and Correcting Improper Inheritance - Error Handling Strategies - Testing Strategies

III Language Facilities

References ('&' type) - New and Delete - Inline Functions - Const Correctness - Namespaces - Using Static - Derived Classes - Access Control - Friend Classes and Friend Functions - Constructors and Destructors -Virtual Functions - Initialization Lists - Operator Overloading - Assignment Operators - Templates - Exception Tactics - Types and RTTI - Containers

IV Topics

Mixing and Overloading with Inheritance - The Big Three (destructors, copy constructors, assignment operators) - Using Objects to Prevent Memory Leaks - Wild Pointers and Other Devilish Errors - High-Performance Software - COM and Active X - Transitioning to CORBA - C Language Considerations - Private and Protected Inheritance - Pointers to Member Functions - The Transition to OO and C++

-

I don't think there are any great C++ books. A great book would eliminate the need for others, which none that I've seen do. Even if not great, this is a good book, and worth reviewing. The book attempts to be two things: first, a programming style guide, and second, a nuts-and-bolts C++ reference book. (Incidentally, the cover is somewhat misleading: it also trumpets coverage of ActiveX, CORBA, and COM, but the material on them here is very thin - if you need to understand them, look elsewhere).

As a programming style guide, it is rather a mixed bag. Its main weakness is a tendency towards salesmanship - that is, the authors are trying to sell you something and are therefore quite aggressive in discussing the merits of their wares and tend to be silent when discussing the weaknesses of them. A particular problem I could point out is the use of C++ in DLLs. If you follow the style guide in this book, and try to put your code into DLL's, you will find that you have some very serious versioning problems, problems the advice in this book was instrumental in creating but useless in alleviating. This doesn't mean that the advice isn't generally good, but there are issues here that the authors are not as frank as they should be in discussing. (I don't know why propaganda of this sort is so common in C++ books, but it is. I've never seen one without it.)

Whatever it may be as a style guide, as a nuts and bolts problem solving book this is really very good. C++ is a large language - it is by far the largest, most complex language ever to find wide use, and there it contains many pitfalls. This book's great strength is in identifying many of these problem areas, and providing solutions to them. The discussion of object construction, copying, and destruction, alone, for example would make this book worth owning. The coverage is not, however, complete. Reader knowledge of language basics is assumed, and some advanced topics, such as multiple inheritance, are not covered. Because of this, you will not find this a good book for learning C++, nor should it be the only C++ book you own.

That said, of all the C++ books I own, this is the one that most often contained the easiest to find, clearest, and best answer to the problems that I actually had when using (as opposed to learning) the language. The answers were generally easiest to find because of the extensive table of contents (it averages about one entry per page) and very complete index. In addition to being easy to find, the answers were also clearly written. There is a lot of sample code in this book, and it is generally very good code for teaching its points. The authors also clearly understand their stuff, and I did not find any of the dreadful this-is-too-technical-for-the-reader hand-waving that so often mars computer industry books. Finally, in addition to being clearly written, the answers were also usually the most complete and thorough I found among the C++ books I own - the problems the book addressed, it addressed very well.

In summary, until and unless that great C++ book is ever written - and I'm not holding my breath - this is a book that almost any C++ developer would do well to have, limits and all.

C++ jocks like to show off, using sophisticated features of the language. How to figure out what the heck they're doing? This is the book. Not only will you figure out what they're doing, you'll learn why -- and become a better programmer. I would call it a combination reference and tutorial.

This book is essential in figuring out what is actually going on, under the covers. As the title says, it's a list of Frequently Asked Questions. For each, there is a short one-line answer, and then, a (much longer) detailed answer, that tells you not only HOW, but WHY, down to the nitty-gritty. It makes no apologies for C++ shortcomings; rather, it points them out and tells you what to do about them. Nearly every question has example code, typically entire programs that can stand alone. Sometimes, there are several examples, illustrating different ways of doing something.

Yes, I first printed out and pored through the online version. I learned a lot. Then I went to the bookstore and looked through this one. And felt amazed at my good fortune -- that such a book exists, and that I had actually found it. I couldn't wait to get out of there with it.

While there are new things that come up from time to time, in the overwhelming number of cases, many others have tried to do what you are doing. The hurdles that you face have almost certainly been leapt by someone else. Furthermore, if the problem that you are having is difficult, then others have also tried and most likely struggled. Finally, one of the most efficient ways to learn to program for production is to study those problems that others have frequently faced. It is quite likely that the problems that many others have had will contain some that you will face at some point. Put all of this together, and lists of Frequently Asked Questions or FAQs are one of the most valuable resources that you can have.
Outside of questions concerning basic syntax, this is the first reference that I consult when I am stuck on a point in C++. Even if the FAQ is not quite what I am doing, in many cases it is close enough so that I can interpolate the proper path. I use this book as a reference so often that I listed it as one of the best books of the year in my "On Books" column that appeared in the September, 1999 issue of _Journal of Object-Oriented Programming_.

I was suggested this book years ago by a university lecturer, however, even though I'm glad I read it, I'm glad simply so I can highlight its pitfalls to others I see reading it.

Firstly, all the way through the book the authors systematically promote the usage of exception specifications. Exception specifications are all well and good when you can guarantee the exceptions that will be thrown from subsequent nested calls or operations, but to teach this behaviour to potentially novice coders, who may not be aware that a particular implementation of operator[] may throw something other than out_of_range is terrible. What's worse, it does it all the way through the book. It also does not highlight the consequences of not handling an exception of a different type. It's C++, not Java. (And, some development environments don't support exception specifications anyway, so much confusion would ensue when code suddenly breaks on a different platform/compiler)

Also, I take exception (groan) to the promotion of "using namespace std". This completely wipes out the point of namespaces, whereby it would have been better (to keep the code examples "clean") to import just the required elements of std, rather than the entire library.

I also don't like the mixed practice of using streams, and then littering strings with escape sequences - the std library defines new line characters (endl), and \n may not be the appropriate behaviour on some platforms.

A great majority of this book feels like it is a C++ guide written by C developers. There are parts that actually teach coders how to break elements of the standard (such as nothrow), rather than simply advocate the use of smart pointers instead. In this way it also pretty much ignores the entirety of the STL (which seems laudible considering the "covers... such major innovations as the C++ Standard Library" line on the back of the book), so readers remain completely oblivious to iterators etc - and also remain blissfully unaware of times when you really would find a functor (functionoid in this book) useful. Instead it harps on about technologies irrelevent to C++ itself - there are many other, better, sources on COM and CORBA, and these sections feel utterly out of place.

The intended target audience of this book is frankly bizarre. It doesn't suit novice programmers because of the techniques it promotes, and, for more advanced developers, is littered with basics such as explaining OO, classes and inheritance. There are also some really preachy parts that go down the software engineering route (Why is OO important to my organisation? etc). If I wanted some condescending essays on programming practice, I'd go and read Fred Brooks. All in all, it feels like a guide for those migrating from C to C++.

This book is out-of-date, teaches bad practice (in my opinion, obviously), and has no defined readership. Like one of the other reviewers here, I would recommend reading Meyer's Effective range of books instead.

Don't even _think_ of writing C++ without reading this book first.

Yes it sometimes preaches ("arrays are evil") and clubs you over the head about the "one true way" of doing things but there's method behind the madness and it's just trying to save you the pain of finding certain things out the hard way. Suffice it to say that if your program has any new[] or delete[] in it then you need to read this book.

Apart from the chapter on arrays <grin> it also has masses of tips to help you write reliable, working C++ programs in the real world. One of my favourites is to "imagine that your '~' key has a big alarm attached to it and red lights will flash every time you press it" (see book for reasons why) will go a long way towards helping you avoid mysterious errors and long debugging sessions.

Apart from the nitty gritty details of C++ the book also has whole sections on programming philosophy and design techniques, how to organize your code to minimize recompiles and all sorts of things to help you work more effectively with this untamed beast we call C++.

Above all, this tries to help you avoid repeating the mistakes and painful learning experiences being suffered by C++ programmers the world over. It's very readable and it _will_ improve your programming technique. Ignore it it at your peril.

Books like this can't get much better. The 3 authors slam through every topic worth mentioning concerning C++ and do it well. There isn't any dogmatic fluff how C++ should take over the world like other books because they aren't caught in the hype of object orientation like the rest of the mindless masses are (e.g. they don't waste their time tearing procedural styles because there are more important things to discuss).

The most eminent thing that the blue faqs reflect is common sense. The authors aren't caught in an endless web of technical nonsense. Of course, the nature of the subject IS technical, but you'll notice and like the fact that the authors know their stuff, and answer the questions you have before you ask them to yourself.

It is absolutely perfect for folks with some C++ experience. The blue faqs put everything together, covering management perspectives, testing strategies, containers, the big three, and a heck of a lot more. In short, it will cover everything you'll need to know to exploit the C++ system of programming. It is simply a wonderful, useful, organized piece of work.

I wouldn't recommend learning C++ off of this book, though. It seems to be aimed more towards individuals that have experience in C++ and design. It might be good for businessmen to gain some insight.

There are pieces of helpful code peppered throughout the book. No excercises (it's not a textbook), no CD-ROM comes with it, either. It's written in a fun, understandable, down to Earth conversational style and gets (VERY) technical where needed. For those who want it, do not worry about not finding rigor in it. This is probably the only book that ever has hit a wonderful balance between the mush than those awful "buzz" books offer and good, technical precision.

Go to Yahoo! and find the Internet version of the C++ faqs, maintained by the authors of the blue faqs and decide for yourself. That has a ton of good stuff in it, but the blue one has 500% more stuff in it.

This is one of the nicest books I ever read. Sure the FAQ form made things simpler for the authors, but also greatly simplifies reading.
One of the few books I think a programmer should read and re-read every now and then. Moreover some of the topics and the very basic ideas are about object oriented programming in general and not just about C++.
On the negatives I must say I was disappointed by the CORBA/DCOM section. I expected more but after thinking about how big that subject can be I would have removed the CORBA/DCOM thing from the cover. The book doesn't need it.

I think that the two best things about the book are:

a) There is a great emphasis on programming the right way. You can learn a lot about the right way to write a program as a programmer, taking in mind the future users of your program.

b) The answers are in a simple to understand and humorous language. Even though the answers are in such a manner you recieve a great deal of information about how the compiler "thinks" and works - what makes this book more interesting than any other text book.

I truly recommend it as a 'must to have' for every programmer in C++.