Effective Modern C++

From the Publisher
Acknowledgments
Introduction

1. Deducing Types
-Understand template type deduction 
-Understand auto type deduction 
-Understand decltype
-Know how to view deduced types 

2auto
-Prefer auto to explicit type declarations 
-Use the explicitly typed initializer idiom when auto deduces undesired types

3. Moving to Modern C++
-Distinguish between () and {} when creating objects
-Prefer nullptr to 0 and NULL
-Prefer alias declarations to typedefs 
-Prefer scoped enums to unscoped enums
-Prefer deleted functions to private undefined ones
-Declare overriding functions override 
-Prefer const_iterators to iterators
-Declare functions noexcept if they won’t emit exceptions
-Use constexpr whenever possible
-Make const member functions thread safe
-Understand special member function generation 

4. Smart Pointers
-Use std::unique_ptr for exclusive-ownership resource management 
-Use std::shared_ptr for shared-ownership resource management 
-Use std::weak_ptr for std::shared_ptr-like pointers that can dangle 
-Prefer std::make_unique and std::make_shared to direct use of new
-When using the Pimpl Idiom, define special member functions in the implementation file 

5. Rvalue References, Move Semantics, and Perfect Forwarding
-Understand std::move and std::forward 
-Distinguish universal references from rvalue references 
-Use std::move on rvalue references, std::forward on universal references 
-Avoid overloading on universal references 
-Familiarize yourself with alternatives to overloading on universal reference
-Understand reference collapsing 
-Assume that move operations are not present, not cheap, and not used
-Familiarize yourself with perfect forwarding failure cases 

6. Lambda Expressions
-Avoid default capture modes 
-Use init capture to move objects into closures
-Use decltype on auto Item 33:&& parameters to std::forward them
-Prefer lambdas to std::bind 

7. The Concurrency API
-Prefer task-based programming to thread-based 
-Specify std::launch::async if asynchronicity is essential
-Make std::threads unjoinable on all paths
-Be aware of varying thread handle destructor behavior 
-Consider void futures for one-shot event communication 
-Use std::atomic for concurrency, volatile for special memory 

8. Tweaks
-Consider pass by value for copyable parameters that are cheap to move and always copied
-Consider emplacement instead of insertion

Index