countdown boutiques-francophones Eco Friendly Cleaning and Care home Kindle sports Tools

There was a problem filtering reviews right now. Please try again later.

Showing 1-10 of 20 reviews(5 star). See all 29 reviews
on August 19, 2003
Frankly this is not a beginner's book. You need some deep knowledge of c++ templates and working knowledge of stl to make the best out of this book.
Aside from introducing some caveats in STL programming, the main achievement of this book is to introduce the more descent part of STL which is less commonly used.
If you only use STL in the same way you use traditional data structure interfaces, this is the book for you.
0Comment|Was this review helpful to you?YesNoReport abuse
on August 9, 2001
I wish I had read this book since the first day I started to use STL. This book covers STL in a depth and width which no other STL books have reached. It is concise, but very clear and comprehensive. Not only does it talk about how to choose from different containers, algorithms, it also thoroguhly explains things, for example, binary_search, equal_range, mem_fun, mem_fun_ref, which other documents talk very little. You may find other books or articles talking about the similiar thing, but not to the depth and width this book reaches.
0Comment|Was this review helpful to you?YesNoReport abuse
on August 5, 2002
This is the third book by Scott Meyers that I've owned. It is, as expected, a joy to read. I find Scott's style of writing easy to follow. Although, I suspect you could find everything that's in this book elsewhere, it would be several elsewhweres. Scott wraps it all up in one neat package. I guess I would summarize its utility in one sentence: "BUY THIS BOOK!"
0Comment|Was this review helpful to you?YesNoReport abuse
on July 3, 2002
This book follows in the manner of Scott Meyers' other excellent C++ books (Effective C++ and More Effective C++). It is divided into 50 "items" covering specific topics in using the Standard C++ Standard Library neatly grouped into 7 chapters on effective use of the containers, iterators and algorithms that make up the Library. This is a very good supplement to more basic and comprehensive books like The C++ Standard Library, by Nicolai Josuttis. Meyers' book assumes you have a basic familiarity with the inventory and interfaces of the STL and shows you how to use the STL more efficiently, safely and clearly. The book can be a little frustrating for those who just want a "do it this way" approach. Each item in the book takes you through the reasoning behind why it's better to use the STL in one way and not another. But, in the long run, this is a much more effective approach. The "why" is as important has the "how". The book also contains plenty of crossreferences between items, so it makes a good reference when you are done reading it through.
0Comment|Was this review helpful to you?YesNoReport abuse
on July 3, 2002
I'm not a professional programmer, but I play one on... Okay, I admit I'm a pretender. I code when I need to, not as an end in and of itself. When I put digits to keyboard, C++ is my language of choice, but often things aren't as clear as they should STL. You gotta love it. Somebody finally comes up with a standardized container library for C++, and it proves to be difficult to do anything but the most basic "stuff it" and "get it" operations...and getting it is sometimes not guaranteed.
Along comes Scott Meyers and Effective STL with 50 specific recommendations on using the STL. Bless you, man...I mean it. This book clears up many misconceptions about the STL and will tidy up your code. It will make you wiser, help you to do things with STL that you didn't even know were possible, and may even make (shhhh!). Its like a slap to the face. It will pull you out of your catatonic state and make you...effective.
So put down the keyboard, stop fondling your mouse, and go read a book. If you know what "STL" stands for, you need this one.
0Comment|Was this review helpful to you?YesNoReport abuse
on July 31, 2001
This is the third in a series of books by Meyers on using C++ effectively. The book follows the same format as the earlier two: Chapters progress from more fundamental issues to more complex ones; each chapter consists of a sequence of related items; each item is presented (loosely speaking) as a "problem description" and the solution for it.
The material covers a wide scope, ranging from stuff that will help first-time STL users (e.g., why to use empty instead of size), to material that helps even long-time STL users.
New STL users should find the sections on selecting the most appropriate containers and algorithms very useful. I know I wish I had read something like this when I started using STL. Even though the material is presented very concisely, it is clearly and thoroughly explained. This is not a cook-book: you will not only learn the right way, but also understand *why* it is the right way.
As an STL user with about 4 years experience, I found the sections on equality vs. equivalence and function objects particularly enlightening. Although perhaps none of this material was completely "new" to me, seeing it all presented logically really crystalized my understanding of these topics.
Meyers discussion of allocators and how to write them is one of the best around. His presentation of why predicates should be stateless is crystal clear (and he makes this the "big deal" it deserves to be).
As far as negatives go, I don't have any major criticism of this book. On a minor note, I wish he had been a bit more thorough in his discussion of techniques for dealing with compile-time bugs in STL code. The book discusses how to read compiler diagnostics, but doesn't discuss some other very useful techniques, such as replacing any user-types in containers with ints. In my experience, this can go a long way to separating problems with STL usage, problems with functor usage, and problems in the underlying class stored in the container. The compiler messages for containers of ints are much clearer. And if you can get your code to work (STL-wise) with containers of ints, it should work then with containers to class X, if X is properly written and the functors are properly written.
Bottomline: this book is a must read for anyone learning to use the STL, and a great review and reference for experienced STLers.
0Comment|Was this review helpful to you?YesNoReport abuse
on July 26, 2001
If you aren't yet convinced that the STL can help you write better C++, I would seriously consider buying and reading this book cover-to-cover. I had heard that STL implementations were far from standard and many people even told me to avoid it entirely. From the very first page of this book, Scott's enthusiasm for the STL was apparent. By the time I finished the book, my own views on STL had changed entirely.
There are plenty of tips and tricks in this book, but more importantly it will show you how to think about using the STL. It's not just the "use std::vector instead of dynamically allocated arrays" that's important, but "the notion of a vector is one that you need not reinvent each time you sit down to code!!". In some sense I have started to see the STL as the lowest common denominator in a great deal of my code, since a lot of it reduces down to a combination of containers, iterators and basic algorithms.
For those of you using Microsoft's Visual C++ 6 or earlier, there is also a great Appendix about the shortcomings in your STL library and several ways to remedy them.
0Comment|Was this review helpful to you?YesNoReport abuse
on July 18, 2001
Effective STL is a great book. It's a worthy successor to Scott Meyers' other two must-have books, Effective C++ and More Effective C++. In fact, this book should have been called Even More Effective C++.
The format's no different from the previous two books. There are 50 very specific tips on STL usage, ranging from the trivial (call empty() instead of size() to check for an empty container) to the obscure (Understand how to use a reverse_iterator's base iterator).
The best tip in the book is the discussion on judicious use of STL algorithms. STL consists of over a hundred algorithms covering just about every possible need you'll have. In most cases, you can greatly improve your code by preferring STL's built-in algorithms to your own, but there are some situations where using the built-in stuff can just render your code unmaintainable.
My only complaint is that I feel a bit ripped off by the last two items. Item 49 discusses STL error messages, but not in enough depth to be useful. Item 50 is a set of reviews of STL-related websites. It appears that the author ran out of gas just before item 50 and decided to "promote" a couple of the appendices to items.
I guess I'll have to dock the book 1/25 of a star, but that still rounds up to five stars. This is a book that you'll want to have if you plan to use STL. End of story.
0Comment|Was this review helpful to you?YesNoReport abuse
on July 5, 2001
There we go - with his well-known sharpness and diligence, Scott absorbed STL in all detail, taught it in seminars, chewed on the ensuing experience, and distilled it all in this book.
I was one of the reviewers and in the beginning I thought that reviewing a book on STL is going to be an easy enough task. I was wrong.
I learned lots of new things on using STL effectively: why `empty()` is better than `size() == 0`, when and how to write custom allocators, how std::string might be implemented, how associative containers distinguish between equality and equivalence, how to implement associative containers as sorted vectors (that's a gem!), and many, many other things that I either had a blurry understanding of, or simply didn't know about. Now I'm glad I do, because my understanding of the STL and the practical use of it are much better.
The book went through an extensive review process; it is really combed and distilled to its finest. I recommend it to any C++ programmer who uses STL - which should be, any C++ programmer, period. Five well deserved stars.
0Comment|Was this review helpful to you?YesNoReport abuse
on June 22, 2001
If you're a C++ programmer who has never used STL, or if you've ever programmed using STL and you've only read documentation on what STL containers and algorithms do (as opposed to how to use them), you must get this book and read it. Your natural inclination as a C++ programmer will prevent you from getting the most from STL. Every one of the 50 items in this book are helpful, and they are often written in a humorous manner, which makes it a very enjoyable (and informative) read.
Lots of STL books tell you what STL containers and algorithms do. Scott teaches you (at least) two things that are hard to get in other books: 1) How the STL containers work and 2) How to best use them for your purposes. If you've ever stared at a 2,000 character error message from STL and just shook your head, if you hand-write loops for simple container operations, if you ever wondered whether you need to write a custom allocator, you need this book. Just by reading and understanding about 1/2 of the items in this book, my knowledge of STL has increased tenfold, and the enjoyable style of the writing made it fun!
0Comment|Was this review helpful to you?YesNoReport abuse