In the terms of Fred Brooks, The Mythical Man Month, or, perhaps, Thomas S. Kuhn, The Structure of Scientific Revolutions, this impressive and exceptional work by Scott Meyers shows how a systems language designed to allow even device driver development is degenerating by committee-submission-creep towards a Java like applications language ...

Effective Modern C++ does give excellent advice on how to cope. Together with Scott Meyers' other three well known works, the programmer working on a low level programming effort systems or device driver or games performance would be able to navigate the shallows and avoid the rocks and riptides ... But, woe betide the high level applications programmer who, frankly, is using the wrong tool for the job ...

Take the C++ 14 general cleanup of types. This was probably needed anyway. But, together with a comprehensive new typeset to make smart pointers usable, and a concurrency API, this low level approach to these matters may make thread safety possible in non kernel operating system executive mode executables built therefrom. However, the question I wish to raise is whether threads really need any more than absolutely minimal use outside application level code ... Scott's treatment of types and pointers with a view to thread safety is comprehensive and well written ... This essential advice will save many an in-betweenst project halfway really not a systems project but really not an applications one either ...

One reason I bought this book was to find out the detail of what lambdas were. Oh God! Remembering Clipper 5.01 from 1993, whose Clipper code-blocks were this half-way house between DEC's PDP-11 TECO macros, which had the awful possibility of self modification, and proper compiled to p-code small functions a la many Pascals, I suspect these lambdas share the problem that Clipper code-blocks had: one could embed a value inside the code-block a single internal state value that the code-block carried around. This idea undermined the whole conception of good code. Expressibility. Efficient. Maintainable. Obvious. Comprehensible. Top-Down.

If one wants to send impenetrablely obscure messages from deep inside one module to deep inside another, not using the call chain, nor the data heap, use explicit operating system semaphores, not such side effects!! Therefore use lambdas with caution, and preferably not at all.

Nevertheless another classic work by the author, noted for his writings on C++!!

Honesty about C++ and the things that can really help you and those things you should manage carefully is what I like most about this book. The author did an exception job helping the reader navigate through C++ to understand the essence of those things that can benefit or most imperil them when using the language. You do need to have a general understanding of C++ before reading the book. Particularly, recent publications from Bjarne Stroustrup would be very helpful. Some knowledge of the STL could be helpful but not entirely necessary. You do not need to be fully versed in OOP or other programming paradigms. The book is paradigm agnostic. It focuses strictly on C++ programming language capabilities and a few standards approved capabilities represented through C++.

Sometimes a good approach to knowledge involves the long way. It seems best to avoid certain shortcuts since good insights may be absent or unavailable when needed. However, there are shorter paths to understanding that are indeed productive. This book is one of those. Rather than spend months or years contending with many of missteps possible without the knowledge presented here, the author makes your use of C++ far more productive and reliable.

Optimal ways to use capabilities in C++ are discussed and demonstrated. You can also read the book and get the impression that some parts of C++11 and C++14 are screwed up. That would be an incorrect view. I am referring to the parts of the book that show that some features of C++ are not what they seem on the surface. A great example are lambdas and their relationship to memory leaks if used improperly. What I see is that certain features or not designed wrong but they are not designed to be used all the time. C++ is like the computer language equivalent of Lego blocks. Not all pieces are designed to be used everywhere and in every case. It also means that when you use C++, you don't really straight code in it like you might in a managed language, but you use it thoughtfully every step of the way. This book shows you some of those considerations that can reduce technical design problems and improve software programs.

To my opinion, people grade books too high. After reading half of it, I can say with full heart, that this book is an adequate book for "jumping" from old C++ to modern C++. the writer (Scott Meyers) presents these differences, and he does it successfully. The writer presents deep knowledge in C++ and the various motivations for different encoding. Though it is a successful book, I can't say everything is understood to me, yet C++ is not an easy language and many iterations are needed.

I recommend this book with full heart.

Just for reference, I graded Stroupstrup "The C++ programming language" a two stars, which to me seems a terrible book!

It is true that Scott Meyers's book are of great quality. However, as someone that owns many of his books, I can say that his writing keeps getting better and his way of explaining concepts much more accessible. This is a trait, as a writer myself, I will like to to attained. The book looks at very important topics for C++11 and C++14. Therefore, this is not a rewrite of his previous book (and those book should be in your library as well). First, I have to say that he mentions that he didn't want to write about type deduction. Well, I didn't want to read it either. However, the fact he placed it in the first part of the book, it has forced me to do so too. This is because I wanted to avoid the elephant in the room, which is the type deduction and continue with the rest. I'm very glad he did write about type deduction in C++11/C++14. My favorite item: Item 35: Prefer task-based programming to thread-programming. Excellent items about lambdas, threads, rvalues, and many others. It is a great book to have if you code in C++. The books that I always keep close right now for C++ are: C++ Primer by Lippman (5th edition), The C++ Standard Library: A Tutorial and Reference (2nd edition) by Josuttis, and Effective Modern C++. I also keep close the API Design for C++ by Reddy.

If you make your living writing C++ code, this book is a long-awaited must-have of guidelines for C++11/14. If you can make sense of this book, then congrats -- you are part of the elite tribe of C++ coders. This book is not for beginners. For those steeped in C++98/03, read the first paragraph of the introduction – if it doesn’t make sense, then you’ll need to bone up on C++11/14 initializers, lambdas, smart pointers and move operations.

C++11/14 continues C++’s “expert-friendly” reputation. Even after 20 years, I find that I really don’t know the language as well as I should. I’ve studied texts from Stroustrup, Lippman and Josuttis after each major release of ANSI/ISO C++, watched MSDN Channel 9 and cppcon videos, and lurked at stackoverflow, but this book pulls the 11/14 pieces together. After reading chapter 5 on move semantics, I realized how clueless I was on the subject – getting move semantics to work is not for the uninitiated.

Be sure to download the errata sheet before digging into the text – it discusses late-breaking tweaks to the standard that influence some of the guidelines.

Having been stuck using C++03 for a very long time, I finally was able to use C++11/14 at work. I started working in the updated language using all the old tricks and feeling like my knowledge was stagnant. Picking up this book enlightened me to all the modern availabilities of the language, and explained a lot of information I had previously heard from coworkers/blogs, but never understood fully. This book alone made me a better C++ developer in a short span of time, and I still use it as a reference today. Get this book and read it.

This book consists of a number of practical recommendations to make use of elegant C++ features that many C++ programmers, like me, have only vague understanding and sometimes prefer sticking to the old fashion. The book also gives readers detailed descriptions of _why_ the C++ committee has added the feature into C++11/14, _how_ it works internally, and the benefits programmers receive in an enjoyable writing style with lots of examples. Unlike the dry cold C++ standard which is not readable for most human being, this book is a perfect guide to master modern C++ and to be a better C++ programmer.

I should elaborate one thing for people who consider purchasing this book. This book does NOT immediately give you a solution to the piece of code you are developing, the bug you are fighting, or the homework you have to turn in this week. That's not what this book is about. Instead, this book helps you cultivate your internals as a C++ programmer to write more correct, compact, and maintainable code, which you would appreciate over time, not today.

This book is the most challenging programming book I have ever encountered. Having spent many years programming in C++ I was hoping to get up to speed on the latest features in C++11/14.

The book examines extreme corner cases in C++ in which you could get into trouble. It assumes you already a highly experienced C++14 programmer. Language in the book is incredibly difficult, and it starts in the beginning. For example on page 16 there is some convoluted example, followed by a comment: "Yes, the syntax looks toxic, but knowing it will score you mondo points with those few souls who care."

It only gets harder from here. Meyers presents topics as if you on the same level as him, so it is written like you have 20+ years of experience in C++ and know every single language feature perfectly. I found myself having to re-read so many sentences over and over that I just kind of gave up trying to understand and kept on reading.

In many chapters the object used to explain the tip is called Widget and the functions are named something like doWork(). I would have preferred more concrete examples.

The book abrupty ends on tip 42 and there is no conclusion. For someone who has worked with C++ as long as Meyers I would have expected more here in terms of a meta-view. Surely he has some opinion on where the language is headed?

This might be a 5-star book for the most experienced of C++ programmers, but if you are just looking to brush up your C++ skills this will be too hard.

E' il libro da avere se avete programmato in C++03 per anni e siete spaesati dalle nuove feature del linguaggio. Il libro spiega, con esempi concreti e parole chiare, come approcciare le novita', quando usarle e come evitare i problemi che questi nuovi costrutti introducono.

El autor da por hecho que ya tienes experiencia con C++, de modo que este libro es para profundizar el conocimiento ya adquirido con los estándares C++11 y C++14.

Si se va iniciando en el lenguaje, se debería comenzar con otro libro (podría recomendar uno cuyo autor es el creador de C++); si ya has tenido un acercamiento con C++ o dominas el estandar C++98, este libro te ayudará a actualizarte.

This was an excellent write up on modern C++ idioms that gave me a great understanding of the new features introduced in C++ 11 and C++14. The style of the author is witty, and light, while at the same time it conveys the educational material in an easy to follow manner. Experience with C++ is recommended before buying this book, as this is a book which focuses more on the how-to, rather than the what-is. As in, this book doesn't tell you what features are in C++ (well it does, but it assumes you know what they do), but it focuses more on how to use those features in an efficient manner.

The book is fairly advanced but carefully explains the topics in an interesting and thorough manner.

An amazing book for learning more about c++ advance topics!! Definitly a must have to your collection. Explanations are well crafted and simple to understand.