Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library (Addison-Wesley Professional Computing Series)
Product ID: 5300187
Desertcart purchases this item on your behalf and handles shipping, customs, and support to Poland.
โThis is Effective C++ volume three โ itโs really that good.โ โ Herb Sutter, independent consultant and secretary of the ISO/ANSI C++ standards committee โThere are very few books which all C++ programmers must have. Add Effective STL to that list.โ โ Thomas Becker, Senior Software Engineer, Zephyr Associates, Inc., and columnist, C/C++ Users Journal C++โs Standard Template Library is revolutionary, but learning to use it well has always been a challenge. Until now. In this book, best-selling author Scott Meyers ( Effective C++ , and More Effective C++ ) reveals the critical rules of thumb employed by the experts โ the things they almost always do or almost always avoid doing โ to get the most out of the library. Other books describe whatโs in the STL. Effective STL shows you how to use it . Each of the bookโs 50 guidelines is backed by Meyersโ legendary analysis and incisive examples, so youโll learn not only what to do, but also when to do it โ and why . Highlights of Effective STL include: Advice on choosing among standard STL containers (like vector and list), nonstandard STL containers (like hash_set and hash_map), and non-STL containers (like bitset). Techniques to maximize the efficiency of the STL and the programs that use it. Insights into the behavior of iterators, function objects, and allocators, including things you should not do. Guidance for the proper use of algorithms and member functions whose names are the same (e.g., find), but whose actions differ in subtle (but important) ways. Discussions of potential portability problems, including straightforward ways to avoid them. Like Meyersโ previous books, Effective STL is filled with proven wisdom that comes only from experience. Its clear, concise, penetrating style makes it an essential resource for every STL programmer. Review: Not timeless, but still a very useful volume - "Effective STL" is the final installment of Scott Meyers' "Effective" trilogy. While the first two volumes ("Effective C++" and "More Effective C++") discussed general tips on C++, "Effective STL" focuses exclusively on the STL, which is taken to mean the parts of the C++ standard library that work with iterators. It goes without saying that this book should be read after "Effective C++, Third Edition". One could probably get away with skipping over "More Effective C++", thus going directly from "Effective C++" to "Effective STL". The Good: in typical Meyers style, the writing is generally relaxed and even pleasant, e.g. "This works, but only if you're not terribly picky about what you mean by 'works'." (Item 7). Like in "Effective C++" (but in contradistinction to "More Effective C++") most Items are quite short and therefore easily digestible. Similarly, in this volume, too, Meyers often reiterates the main point of each Item before concluding: this sometimes feels needlessly repetitive, but is mostly great for driving home the essential issues. As in the earlier volumes, things are for the most part organized intuitively. Meyers has a knack for pedagogy and thus for different ways of getting the message across, cf. the few tables that are included in the book, most notably the one on search options in Item 45. The author's organizational prowess is also evidenced by the numerous cross-references and the list of performance-related Items at the end of the Introduction. Moving on to the specifics of the material covered in this volume: Meyers is at his best when addressing a host of topics that elsewhere are often jumbled together. The finest examples of this skill are Items 31, 41, and 45, which deal with sorting options, function adapters, and search algorithms, respectively. Meyers manages to methodically explain the commonalities and distinctions between related concepts. The overwhelming majority of the topics covered in this volume have to do with real-life programming in C++, e.g. how to pass vector and string data to legacy APIs (Item 16). In this vein, some of the Items in "Effective STL" can safely be said to constitute required reading, especially the following on: a) range member functions versus their single-element counterparts (Item 5), b) C++'s most vexing parse (Item 6), c) the swap trick used to eliminate excess capacity (Item 17), d) the erase-remove idiom that allows one to really remove elements from a container (Item 32), e) the superiority of algorithm calls in comparison with hand-written loops (Item 43), and f) the advantages of container member functions over STL algorithms with the same name (Item 44). Other Items feel like digressions (e.g. Item 10 on allocators, Item 18 on vector of bools, or Item 23 on replacing associative containers with sorted vectors) though that doesn't make them any less interesting. The Bad: this volume is not introductory but it isn't a very good reference either. For example, in the early Items Meyers talks about list's splice member functions matter-of-factly. Of course, "Effective C++" and "More Effective C++" are also not introductory or reference works, but there's a major difference: in those books when Meyers discusses a new construct he first explains it briefly. In "Effective STL", on the other hand, he often implicitly assumes the reader will go look stuff up in something like Josuttis' book "The C++ Standard Library" (regarding which Meyers writes: "[e]very C++ programmer should have ready access to a copy"). Obviously, a short hints-and-tips type book cannot contain everything, but the reader's life would have been made much easier had Meyers simply included a few reference tables (containing function signatures) in an Appendix. Moreover, what the Appendices do include is not uniformly interesting: Appendix B addresses developers using Microsoft Visual C++ versions 4-6 and is therefore largely irrelevant today. Another point where "Effective STL" diverges slightly from the earlier volumes' practices is cross-referencing. Meyers mentions other Items extensively in those books, too, but here he's gone overboard: for example, by the time he introduces unary_function and binary_function in Item 40, he has referred to them 10 times already, which probably means that they should have been covered (way) earlier. On a different note, given the non-exhaustive nature of the book, there's important stuff that's missing, e.g. there's absolutely no mention of the at() member function of vectors, deques, and strings. Also, a few of the examples feel somewhat contrived (e.g. anyone paying attention up to that point can tell that the initially proposed solution in Item 42 is obviously unnecessary), though this is more the exception than the rule. Finally, the book's age is starting to show: "Effective STL" was published in 2001 so (despite being more up to date than "More Effective C++") a number of things would be done differently today. For example, Meyers uses for_each in many code snippets, most of which would look much cleaner using lambdas. In a nutshell, I would say that this book is not as indispensable as "Effective C++, Third Edition", but is probably more useful than "More Effective C++". Meyers is a talented author and instructor, so all three volumes are worth reading. Were "Effective STL" to be re-written today (using C++11 and its library) the result would certainly be more interesting, but the advice contained in this book is solid, nonetheless. Overall, four and a half stars. Alex Gezerlis Review: improved my code immediately - I'm a professional software engineer. I write code all day long and have lots of experience with C++, but I hadn't used STL much until recently. If you're in a similar situation--decent C++ knowledge but not an STL expert--this book is for you. I haven't even read the whole thing yet, and already I am using patterns from the book to write more effective code. Before I started this book, I thought STL was kind of neat. It had some useful containers. It was nice to be able to use a list or map or string class that had already been tested. Boy, was I underestimating the power of STL. This book has made me a big STL fan, but I'm not reviewing the STL now so I'll leave that topic alone... Thanks to Scott Meyers, I have a much better grasp of the capabilities and limitations of STL. I can use it to do a lot more. I write more concise code that's easier to read and debug. I make better choices about which containers to use. I recognize situations where I can use an STL algorithm instead of many lines of my own code. In short, I look at the STL code I wrote before and laugh... I mean, it all works, but the Meyers book has taken my use of (and appreciation for) the STL to a whole new level. I recommend this book for any C++ developer who isn't already an STL expert. An update, 2 years after the above text was written: I still recommend this book to people and still think it's the best STL book I've read.
| Best Sellers Rank | #517,808 in Books ( See Top 100 in Books ) #144 in C++ Programming Language #976 in Computer Programming Languages #1,492 in Computer Software (Books) |
| Customer Reviews | 4.5 out of 5 stars 182 Reviews |
A**G
Not timeless, but still a very useful volume
"Effective STL" is the final installment of Scott Meyers' "Effective" trilogy. While the first two volumes ("Effective C++" and "More Effective C++") discussed general tips on C++, "Effective STL" focuses exclusively on the STL, which is taken to mean the parts of the C++ standard library that work with iterators. It goes without saying that this book should be read after "Effective C++, Third Edition". One could probably get away with skipping over "More Effective C++", thus going directly from "Effective C++" to "Effective STL". The Good: in typical Meyers style, the writing is generally relaxed and even pleasant, e.g. "This works, but only if you're not terribly picky about what you mean by 'works'." (Item 7). Like in "Effective C++" (but in contradistinction to "More Effective C++") most Items are quite short and therefore easily digestible. Similarly, in this volume, too, Meyers often reiterates the main point of each Item before concluding: this sometimes feels needlessly repetitive, but is mostly great for driving home the essential issues. As in the earlier volumes, things are for the most part organized intuitively. Meyers has a knack for pedagogy and thus for different ways of getting the message across, cf. the few tables that are included in the book, most notably the one on search options in Item 45. The author's organizational prowess is also evidenced by the numerous cross-references and the list of performance-related Items at the end of the Introduction. Moving on to the specifics of the material covered in this volume: Meyers is at his best when addressing a host of topics that elsewhere are often jumbled together. The finest examples of this skill are Items 31, 41, and 45, which deal with sorting options, function adapters, and search algorithms, respectively. Meyers manages to methodically explain the commonalities and distinctions between related concepts. The overwhelming majority of the topics covered in this volume have to do with real-life programming in C++, e.g. how to pass vector and string data to legacy APIs (Item 16). In this vein, some of the Items in "Effective STL" can safely be said to constitute required reading, especially the following on: a) range member functions versus their single-element counterparts (Item 5), b) C++'s most vexing parse (Item 6), c) the swap trick used to eliminate excess capacity (Item 17), d) the erase-remove idiom that allows one to really remove elements from a container (Item 32), e) the superiority of algorithm calls in comparison with hand-written loops (Item 43), and f) the advantages of container member functions over STL algorithms with the same name (Item 44). Other Items feel like digressions (e.g. Item 10 on allocators, Item 18 on vector of bools, or Item 23 on replacing associative containers with sorted vectors) though that doesn't make them any less interesting. The Bad: this volume is not introductory but it isn't a very good reference either. For example, in the early Items Meyers talks about list's splice member functions matter-of-factly. Of course, "Effective C++" and "More Effective C++" are also not introductory or reference works, but there's a major difference: in those books when Meyers discusses a new construct he first explains it briefly. In "Effective STL", on the other hand, he often implicitly assumes the reader will go look stuff up in something like Josuttis' book "The C++ Standard Library" (regarding which Meyers writes: "[e]very C++ programmer should have ready access to a copy"). Obviously, a short hints-and-tips type book cannot contain everything, but the reader's life would have been made much easier had Meyers simply included a few reference tables (containing function signatures) in an Appendix. Moreover, what the Appendices do include is not uniformly interesting: Appendix B addresses developers using Microsoft Visual C++ versions 4-6 and is therefore largely irrelevant today. Another point where "Effective STL" diverges slightly from the earlier volumes' practices is cross-referencing. Meyers mentions other Items extensively in those books, too, but here he's gone overboard: for example, by the time he introduces unary_function and binary_function in Item 40, he has referred to them 10 times already, which probably means that they should have been covered (way) earlier. On a different note, given the non-exhaustive nature of the book, there's important stuff that's missing, e.g. there's absolutely no mention of the at() member function of vectors, deques, and strings. Also, a few of the examples feel somewhat contrived (e.g. anyone paying attention up to that point can tell that the initially proposed solution in Item 42 is obviously unnecessary), though this is more the exception than the rule. Finally, the book's age is starting to show: "Effective STL" was published in 2001 so (despite being more up to date than "More Effective C++") a number of things would be done differently today. For example, Meyers uses for_each in many code snippets, most of which would look much cleaner using lambdas. In a nutshell, I would say that this book is not as indispensable as "Effective C++, Third Edition", but is probably more useful than "More Effective C++". Meyers is a talented author and instructor, so all three volumes are worth reading. Were "Effective STL" to be re-written today (using C++11 and its library) the result would certainly be more interesting, but the advice contained in this book is solid, nonetheless. Overall, four and a half stars. Alex Gezerlis
E**T
improved my code immediately
I'm a professional software engineer. I write code all day long and have lots of experience with C++, but I hadn't used STL much until recently. If you're in a similar situation--decent C++ knowledge but not an STL expert--this book is for you. I haven't even read the whole thing yet, and already I am using patterns from the book to write more effective code. Before I started this book, I thought STL was kind of neat. It had some useful containers. It was nice to be able to use a list or map or string class that had already been tested. Boy, was I underestimating the power of STL. This book has made me a big STL fan, but I'm not reviewing the STL now so I'll leave that topic alone... Thanks to Scott Meyers, I have a much better grasp of the capabilities and limitations of STL. I can use it to do a lot more. I write more concise code that's easier to read and debug. I make better choices about which containers to use. I recognize situations where I can use an STL algorithm instead of many lines of my own code. In short, I look at the STL code I wrote before and laugh... I mean, it all works, but the Meyers book has taken my use of (and appreciation for) the STL to a whole new level. I recommend this book for any C++ developer who isn't already an STL expert. An update, 2 years after the above text was written: I still recommend this book to people and still think it's the best STL book I've read.
S**A
good STL book
I bought this book in a hurry for the purpose of using STL functions for my programming project. It does have some very good and useful advises and tips for dealing with various problems, and is not assuming the reader of it is too much of an entry level programmer. However, my biggest complaint of it is the print layout, including its font/size/color, the font is too heavy and dark (almost all Bold like) and make it harder to read through, especially some C++ code section which should definitely be printed in smaller, lighter and program code like style which is unfortunately not.
M**X
One helluva book
I was brought up on STL with C++, and can't imagine the language without it. This book, however, opened my eyes to many of the strengths, weaknesses, and issues of the Standard Template Library. It tells the reader why to use a deque of booleans instead of vector<bool>. More importantly, it provides warnings about features to avoid, as well as how to make better use of this now standard library. Open source software contributors should also check this book out to understand best practices. There's a temptation in C++ to treat iterators like pointers, but Scott Meyers explains clearly why you shouldn't. He briefly discusses the 100 algorithms that are offered in STL, and several key Items, like "Item 30: Make sure destination ranges are big enough" and "Item 32: Follow remove-like algorithms by erase if you really want to remove something." Readers even get some of the back story on the decisions that went into the development of STL and why they made some of the compromises that they did. The book is so clear, so lucid, and so interesting that even the novice C++ programmer will enjoy its prose. It is thoroughly informative even for programmers at all levels of experience with C++.
G**W
Buy It Now!
I am a generally experienced C++ programmer, but I haven't dealt with STL very much. I plan to use it a lot more in the near future, and this sounded to me like a book that would be useful to avoid a lot of pitfalls and establish good habits right off the bat. Man, was this book a smart buy! I would give it 6 stars if I could. It doesn't take one very long to realize that this book is chock full of insight and wisdom. Every item he presents is a gem. In addition, Mr. Meyers' writing style is more conversational than techie. Don't misunderstand. He really gets into the nitty-gritty of compiler internals and such, but he does it in a way that makes it much more easy to read than material written by holier-than-thou, academia types. This was the first time I read anything by Mr. Meyers, but based on the quality of this book I plan on buying his "Effective C++" books in the near future.
J**T
Standard Template Advice
This book will help you make better progamming decisons when it comes time to use the STL in a project. Scott Meyer is one of the best writers on the subject of programming. Here he shows you how to best use the Standard Template Library and avoid some of it's dangers. His examples are clear and help you better understand the rationale for his advice. His writing style is terse but pleasant. This is not a tutorial on the STL, nor is it a comprehensive reference. You should already know the basics to get the most form Meyer's book. It does illustrate the best practices for using the STL. Anyone using C++ should read this book and "Effective C++", too. The only problem with these books, is that you may feel like rewriting some of your existing code after reading them. I did.
W**L
Converted a hard-core C programmer to the STL!
I thought this book was great. It gave me allot of good ideas and showed me how to things I didn't know how to before. But the real selling point was that I loaned it to a coworker who was a hard-core C programmer. He scoffed at C++ and OOP in general; making statements like "Everything I need to do can be done in C". After reading three items in the book he was questioning his thinking and trying new things. His latest project is not only in C++ but it's also embedded in the STL. He's taken quite a liking to it and has learned a lot of new things. While I wouldn't recommend this book for a beginner, anyone that wants to further his or her understanding of the STL should read this book cover to cover.
B**L
Did not realise this was an international seller
Being international seller it took a good 4 weeks to arrive. Book was as good as new only for a fold mark in the back cover page running vertically down the whole cover. Just started reading. Book does give a good insight for those who want to understand what can go wrong using STL, Can take you from a beginner level to an advanced level, if not expert level.
V**N
kann nicht besser sein
Ich hoffe es gibt bei allen Programmiersprachen ein so gutes Buch wie dieses. Bist Du Anfรคnger bei Programmierung? Dann bleib weg von dem und schau mal TCPL von Stroustrup an. Hast Du schon Erfahrung mit (am besten) verschiedenen Programmiersprachen, dann alle Bรผcher der Serie "Effective ..." von Meyers sind "Must Read", damit man wirklich richtig mit C++ arbeiten kann. Leider, dass so ein gutes Buch nicht in gebundener Ausgabe publiziert wurde.
A**R
Five Stars
Good Book
T**N
Very Effective Resource for C++
This book will greatly improve the quality of your C++ programs and designs. Not for beginners; you must have a decent understanding of C++ for this to be any help.
C**N
Really helpfull
I read this book and I think I can use it to improve my knowledges about STL
S**E
Must have
I've now bought all of Scott Meyers' books, and if you have anything to do with C++ then I strongly recommend you do the same. Frankly, they are a must-have collection that describe the best way of writing C++ and using the STL. If only they'd been available all those years ago when I first learnt C++ , then I could have saved myself much grief! Scott's style is very informal and readable. Not only does he make difficult topics easy to understand, but he does so in an interesting and accessible manner. It's worth pointing out that these books are not intended for learning C++ from scratch, rather they are intended to show you the best ways of applying your knowledge in solving many common programming problems. This STL book focuses on getting the most out of the standard library functions, and avoiding the many pitfalls and misconceptions. All the items are explained with useful code examples (some of which may well find their way into your own libraries of most used functions/templates). Reading this book, not only do you fully understand the STL functions and how to use them properly, but also when to use them and why one may be much better suited to your particular task than the other (similar) functions. In short, buy it (and his companion books)!
Trustpilot
1 month ago
1 week ago