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++!!
Buy
$49.99 with 2 percent savings
Buy
$49.99 with 2 percent savings
$49.99 with 2 percent savings
Digital List Price: $50.99 
The Digital List Price is the suggested price provided by the publisher for the eBook format.
Learn more
Learn more
Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Customers who bought this item also bought
Page 1 of 1 Start overPage 1 of 1
From the brand
-
Your partner in learning
-
Bestsellers
-
Software Development
-
Programming Languages
-
AI / Machine Learning
-
Data Science
-
Data, Databases and more
-
Cloud Services
-
Business
-
Finance
-
Blockchain / Cryptocurrency
-
Security
-
Cookbooks
-
Head First series
-
97 Things series
-
Lean series
-
Sharing the knowledge of experts
O'Reilly's mission is to change the world by sharing the knowledge of innovators. For over 40 years, we've inspired companies and individuals to do new things (and do them better) by providing the skills and understanding that are necessary for success.
Our customers are hungry to build the innovations that propel the world forward. And we help them do just that.
From the Publisher
From the Introduction
If you’re an experienced C++ programmer and are anything like me, you initially approached C++11 thinking, “Yes, yes, I get it. It’s C++, only more so.” But as you learned more, you were surprised by the scope of the changes. auto declarations, range-based for loops, lambda expressions, and rvalue references change the face of C++, to say nothing of the new concurrency features. And then there are the idiomatic changes. 0 and typedefs are out, nullptr and alias declarations are in. Enums should now be scoped. Smart pointers are now preferable to built-in ones. Moving objects is normally better than copying them.
There’s a lot to learn about C++11, not to mention C++14.
More importantly, there’s a lot to learn about making effective use of the new capabilities. If you need basic information about “modern” C++ features, resources abound, but if you’re looking for guidance on how to employ the features to create software that’s correct, efficient, maintainable, and portable, the search is more challenging. That’s where this book comes in. It’s devoted not to describing the features of C++11 and C++14, but instead to their effective application.
The information in the book is broken into guidelines called Items. Want to understand the various forms of type deduction? Or know when (and when not) to use auto declarations? Are you interested in why const member functions should be thread safe, how to implement the Pimpl Idiom using std::unique_ptr, why you should avoid default capture modes in lambda expressions, or the differences between std::atomic and volatile? The answers are all here. Furthermore, they’re platform-independent, Standards-conformant answers. This is a book about portable C++.
The Items in this book are guidelines, not rules, because guidelines have exceptions. The most important part of each Item is not the advice it offers, but the rationale behind the advice. Once you’ve read that, you’ll be in a position to determine whether the circumstances of your project justify a violation of the Item’s guidance. The true goal of this book isn’t to tell you what to do or what to avoid doing, but to convey a deeper understanding of how things work in C++11 and C++14.
About the author
Counterfeit product
As you can see, the spine has no writing and the back cover text is cut off. Definitely a fake product and I’m disappointed Amazon would allow this blatantly counterfeit product to sell.
Top reviews from the United States
There was a problem filtering reviews. Please reload the page.
- Reviewed in the United States on January 26, 2015
- Reviewed in the United States on December 26, 2014
- Reviewed in the United States on August 27, 2017
- Reviewed in the United States on September 6, 2016
Top reviews from other countries
-
panskReviewed in Italy on February 17, 2016
Il libro piu' importante per il programmatore C++ moderno
-
-
-
