Chronologie des derniers temps (d'après la doctrine traditionnelle des Cycles cosmiques)

Preface Who this book is for What this book covers Get the most out of this book Download the example code files Download the color images Conventions used Get in touch Reviews A Brief Introduction to C++ Why C++? Zero-cost abstractions Programming languages and machine code abstractions Abstractions in other languages The zero-overhead principle Portability Robustness C++ of today C++ compared with other languages Competing languages and performance Non-performance-related C++ language features Value semantics Const correctness Object ownership Deterministic destruction in C++ Avoiding null objects using C++ references Drawbacks of C++ Libraries and compilers used in this book Summary Essential C++ Techniques Automatic type deduction with the auto keyword Using auto in function signatures Forwarding the return type using decltype(auto) Using auto for variables A const reference A mutable reference A forwarding reference Practices for ease of use Const propagation for pointers Move semantics explained Copy-construction, swap, and move Copy-constructing an object Resource acquisition and the rule of five Named variables and rvalues Default move semantics and the rule of zero Rule of zero in a real code base A common pitfall – moving non-resources Applying the && modifier to class member functions Don't move when copies are elided anyway Pass by value when applicable Cases where pass-by-value is not applicable Moving constructor parameters Designing interfaces with error handling Contracts Class invariants Maintaining contracts Error handling Programming error or runtime error? Programming errors (bugs) Recoverable runtime errors Function objects and lambda expressions The basic syntax of a C++ lambda The capture clause Capture by reference versus capture by value Similarities between a lambda and a class Initializing variables in capture Mutating lambda member variables Capture all Assigning C function pointers to lambdas Lambda types Lambdas and std::function Implementing a simple Button class with std::function Performance consideration of std::function Generic lambdas Summary Analyzing and Measuring Performance Asymptotic complexity and big O notation Growth rates Amortized time complexity What to measure and how? Performance properties Speedup of execution time Performance counters Performance testing — best practices Knowing your code and hot spots Instrumentation profilers Sampling profilers Microbenchmarking Amdahl's law Pitfalls of microbenchmarking A microbenchmark example Summary Data Structures The properties of computer memory The standard library containers Sequence containers Vectors and arrays Deque List and forward_list The basic_string Associative containers Ordered sets and maps Unordered sets and maps Container adaptors Priority queues Using views Avoiding copies with string_view Eliminating array decay with std::span Some performance considerations Balancing between complexity guarantees and overhead Knowing and using the appropriate API functions Parallel arrays Summary Algorithms Introducing the standard library algorithms Evolution of the standard library algorithms Solving everyday problems Iterating over a sequence Generating elements Sorting elements Finding elements Finding using binary search Testing for certain conditions Counting elements Minimum, maximum, and clamping Iterators and ranges Introducing iterators Sentinel values and past-the-end iterators Ranges Iterator categories Features of the standard algorithms Algorithms do not change the size of the container Algorithms with output require allocated data Algorithms use operator==() and operator