Chapter 1 Formal Deduction
Item 1: Know the template format deduction rules.
Item 2: Know the formal deduction rules for auto.
Item 3: Familiarize yourself with how decltype works.
Item 4: Know how to identify deduced forms.

Chapter 2 auto
Item 5: Prefer auto over explicit type declarations.
Item 6: Use an explicit initializer when auto deduces an undesirable type.

Chapter 3: Adapting to Modern C++
Item 7: Distinguish between parentheses (()) and braces ({}) when creating objects.
Item 8: Prefer nullptr to 0 and NULL
Item 9: Prefer alias declarations to typedefs.
Item 10: Prefer scoped enums over unscoped enums.
Item 11: Prefer deleted functions over undefined private functions.
Item 12: Declare override functions as overrides.
Item 13: Prefer const_iterator over iterator.
Item 14: Declare functions that do not throw exceptions as noexcept.
Item 15: Use constexpr whenever possible.
Item 16: Make const member functions thread-safe.
Item 17: Know the automatic generation conditions for special member functions.

Chapter 4 Smart Pointers
Item 18: Use std::unique_ptr for managing exclusive-ownership resources.
Item 19: Use std::shared_ptr for managing shared-ownership resources.
Item 20: If you need a pointer that behaves like std::shared_ptr but can lose its target, use std::weak_ptr.
Item 21: Prefer std::make_unique and std::make_shared to using new directly.
Item 22: When using the Pimpl idiom, define special member functions in the implementation file.

Chapter 5 Right-hand References, Move Semantics, and Perfect Forwarding
Item 23: Familiarize yourself with std::move and std::forward.
Item 24: Distinguish between universal references and rvalue references.
Item 25: Use std::move for rvalue references and std::forward for universal references.
Item 26: Avoid double-loading universal references.
Item 27: Know techniques to use instead of overloading universal references.
Item 28: Know your reference abbreviations.
Item 29: Assume that move operations do not exist, are not cheap, and are not applicable.
Item 30: Know when perfect communication fails.

Chapter 6 Lambda Expressions
Item 31: Avoid default galmuri mode
Item 32: Use initializers to move objects into closures.
Item 33: Use decltype for auto&& parameters passed via std::forward
Item 34: Prefer lambdas over std::bind

Chapter 7 Concurrency API
Item 35: Prefer task-based programming over thread-based programming.
Item 36: Specify std::launch::async when asynchrony is required.
Item 37: Make std::threads non-joinable on all paths.
Item 38: Beware of the Different Behaviors of Thread Handle Destructors
Item 39: Consider void future objects for one-shot event communication.
Item 40: Use std::atomic for concurrency, and volatile for special memory.

Chapter 8: Refining
Item 41: Consider passing by value for copyable parameters that are cheap to move and always copied.
Item 42: Consider constructive inserts instead of inserts.