Cargando…
C++ high performance : boost and optimize the performance of your C++ 17 code /
C++ is a highly portable language and can be used to write both large-scale applications and performance-critical code. It has evolved over the last few years to become a modern and expressive language. This book will guide you through optimizing the performance of your C++ apps by allowing them to...
| Clasificación: | Libro Electrónico |
|---|---|
| Autor principal: | |
| Formato: | Electrónico eBook |
| Idioma: | Inglés |
| Publicado: |
Birmingham, UK :
Packt Publishing,
2018.
|
| Temas: | |
| Acceso en línea: | Texto completo (Requiere registro previo con correo institucional) |
MARC
| LEADER | 00000cam a2200000 i 4500 | ||
|---|---|---|---|
| 001 | OR_on1024148075 | ||
| 003 | OCoLC | ||
| 005 | 20231017213018.0 | ||
| 006 | m o d | ||
| 007 | cr unu|||||||| | ||
| 008 | 180223s2018 enka o 000 0 eng d | ||
| 040 | |a UMI |b eng |e rda |e pn |c UMI |d STF |d TOH |d OCLCF |d CEF |d KSU |d OCLCQ |d DEBBG |d G3B |d LVT |d S9I |d UAB |d OCLCQ |d OCLCO |d OCLCQ |d OCLCO | ||
| 020 | |a 9781787124776 | ||
| 020 | |a 1787124770 | ||
| 020 | |a 1787120953 | ||
| 020 | |a 9781787120952 | ||
| 020 | |z 9781787120952 | ||
| 029 | 1 | |a GBVCP |b 1016523971 | |
| 035 | |a (OCoLC)1024148075 | ||
| 037 | |a CL0500000942 |b Safari Books Online | ||
| 050 | 4 | |a QA76.73.C153 | |
| 082 | 0 | 4 | |a 005.1 |
| 049 | |a UAMI | ||
| 100 | 1 | |a Sehr, Viktor, |e author. | |
| 245 | 1 | 0 | |a C++ high performance : |b boost and optimize the performance of your C++ 17 code / |c Viktor Sehr, Björn Andrist. |
| 246 | 3 | |a C plus plus high performance | |
| 264 | 1 | |a Birmingham, UK : |b Packt Publishing, |c 2018. | |
| 300 | |a 1 online resource (1 volume) : |b illustrations | ||
| 336 | |a text |b txt |2 rdacontent | ||
| 337 | |a computer |b c |2 rdamedia | ||
| 338 | |a online resource |b cr |2 rdacarrier | ||
| 347 | |a data file | ||
| 588 | 0 | |a Online resource; title from title page (Safari, viewed February 22, 2018). | |
| 505 | 0 | |a Cover -- Title Page -- Copyright and Credits -- Packt Upsell -- Foreword -- Contributors -- Table of Contents -- Preface -- Chapter 1: A Brief Introduction to C++ -- Why C++? -- Zero-cost abstractions -- Programming languages and machine code abstractions -- Abstractions in other languages -- Portability -- Robustness -- C++ of today -- The aim of this book -- Expected knowledge of the reader -- C++ compared with other languages -- Competing languages and performance -- Non-performance-related C++ language features -- Value semantics -- Const correctness -- Object ownership and garbage collection in C++ -- Avoiding null objects using C++ references -- Drawbacks of C++ -- Class interfaces and exceptions -- Strict class interfaces -- Error handling and resource acquisition -- Preserving the valid state -- Resource acquisition -- Exceptions versus error codes -- Libraries used in this book -- Summary -- Chapter 2: Modern C++ Concepts -- Automatic type deduction with the auto keyword -- Using auto in function signatures -- Using auto for variables -- Const reference -- Mutable reference -- Forwarding reference -- Conclusion -- The lambda function -- Basic syntax of a C++ lambda function -- The capture block -- Capture by reference versus capture by value -- Similarities between a Lambda and a class -- Initializing variables in capture -- Mutating lambda member variables -- Mutating member variables from the compiler's perspective -- Capture all -- Assigning C function pointers to lambdas -- Lambdas and std::function -- Assigning lambdas to std::functions -- Implementing a simple Button class with std::function -- Performance consideration of std::function -- An std::function cannot be inlined -- An std::function heap allocates and captures variables -- Invoking an std::function requires a few more operations than a lambda -- The polymorphic lambda. | |
| 505 | 8 | |a Creating reusable polymorphic lambdas -- Const propagation for pointers -- Move semantics explained -- Copy-construction, swap, and move -- Copy-constructing an object -- Swapping two objects -- Move-constructing an object -- Resource acquisition and the rule of three -- Implementing the rule of three -- Constructor -- Limitations of the rule of three -- Avoiding copies without move semantics -- Introducing move semantics -- Named variables and r-values -- Accept arguments by move when applicable -- Default move semantics and the rule of zero -- Rule of zero in a real code base -- A note on empty destructors -- A common pitfall -- moving non-resources -- Applying the & & modifier to class member functions -- Representing optional values with std::optional -- Optional return values -- Optional member variables -- Sorting and comparing std::optional -- Representing dynamic values with std::any -- Performance of std::any -- Summary -- Chapter 3: Measuring Performance -- Asymptotic complexity and big O notation -- Growth rates -- Amortized time complexity -- What to measure? -- Performance properties -- Performance testing -- best practices -- Knowing your code and hot spots -- Profilers -- Instrumentation profilers -- Sampling profilers -- Summary -- Chapter 4: Data Structures -- Properties of computer memory -- STL containers -- Sequence containers -- Vector and array -- Deque -- List and forward_list -- The basic_string -- Associative containers -- Ordered sets and maps -- Unordered sets and maps -- Hash and equals -- Hash policy -- Container adaptors -- Priority queues -- Parallel arrays -- Summary -- Chapter 5: A Deeper Look at Iterators -- The iterator concept -- Iterator categories -- Pointer-mimicking syntax -- Iterators as generators -- Iterator traits -- Implementing a function using iterator categories. | |
| 505 | 8 | |a Extending the IntIterator to bidirectional -- Practical example -- iterating floating point values within a range -- Illustrated usage examples -- Utility functions -- How to construct a linear range iterator -- Iterator usage example -- Generalizing the iterator pair to a range -- The make_linear_range convenience function -- Linear range usage examples -- Summary -- Chapter 6: STL Algorithms and Beyond -- Using STL algorithms as building blocks -- STL algorithm concepts -- Algorithms operate on iterators -- Implementing a generic algorithm that can be used with any container -- Iterators for a range point to the first element and the element after the last -- Algorithms do not change the size of the container -- Algorithms with output require allocated data -- Algorithms use operator== and operator<by default -- Custom comparator function -- General-purpose predicates -- Algorithms require move operators not to throw -- Algorithms have complexity guarantees -- Algorithms perform just as well as C library function equivalents -- STL algorithms versus handcrafted for-loops -- Readability and future-proofing -- Real-world code base example -- Usage examples of STL algorithms versus handcrafted for-loops -- Example 1 -- Unfortunate exceptions and performance problems -- Example 2 -- STL has subtle optimizations even in simple algorithms -- Sorting only for the data you need to retrieve -- Use cases -- Performance evaluation -- The future of STL and the ranges library -- Limitations of the iterators in STL -- Introduction to the ranges library -- Composability and pipeability -- Actions, views, and algorithms -- Actions -- Views -- Algorithms -- Summary -- Chapter 7: Memory Management -- Computer memory -- The virtual address space -- Memory pages -- Thrashing -- Process memory -- Stack memory -- Heap memory -- Objects in memory. | |
| 505 | 8 | |a Creating and deleting objects -- Placement new -- The new and delete operators -- Memory alignment -- Padding -- Memory ownership -- Handling resources implicitly -- Containers -- Smart pointers -- Unique pointer -- Shared pointer -- Weak pointer -- Small size optimization -- Custom memory management -- Building an arena -- A custom memory allocator -- Summary -- Chapter 8: Metaprogramming and Compile-Time Evaluation -- Introduction to template metaprogramming -- Using integers as template parameters -- How the compiler handles a template function -- Using static_assert to trigger errors at compile time -- Type traits -- Type trait categories -- Using type traits -- Receiving the type of a variable with decltype -- Conditionally enable functions based on types with std::enable_if_t -- Introspecting class members with std::is_detected -- Usage example of is_detected and enable_if_t combined -- The constexpr keyword -- Constexpr functions in a runtime context -- Verify compile-time computation using std::integral_constant -- The if constexpr statement -- Comparison with runtime polymorphism -- Example of generic modulus function using if constexpr -- Heterogeneous containers -- Static-sized heterogenous containers -- The std::tuple container -- Accessing the members of a tuple -- Iterating std::tuple -- Unrolling the tuple -- Implementing other algorithms for tuples -- Accessing tuple elements -- Structured bindings -- The variadic template parameter pack -- An example of a function with variadic number of arguments -- How to construct a variadic parameter pack -- Dynamic-sized heterogenous containers -- Using std::any as the base for a dynamic-size heterogenous container -- The std::variant -- Visiting variants -- Heterogenous container of variants -- Accessing the values in our variant container -- Global function std::get. | |
| 505 | 8 | |a Real world examples of metaprogramming -- Example 1 -- Reflection -- Making a class reflect its members -- C++ libraries which simplifies reflection -- Using the reflection -- Evaluating the assembler output of the reflection -- Conditionally overloading global functions -- Testing reflection capabilities -- Example 2 -- Creating a generic safe cast function -- Example 3 -- Hash strings at compile time -- The advantages of compile-time hash sum calculation -- Implement and verify a compile-time hash function -- Constructing a PrehashedString class -- Forcing PrehashedString to only accept compile time string literals -- Evaluating PrehashedString -- Evaluating get_bitmap_resource() with PrehashedString -- Summary -- Chapter 9: Proxy Objects and Lazy Evaluation -- An introduction to lazy evaluation and proxy objects -- Lazy versus eager evaluation -- Proxy objects -- Comparing concatenated strings using a proxy -- Implementing the proxy -- Performance evaluation -- The r-value modifier -- Assigning a concatenated proxy -- Postponing an sqrt computation when comparing distances -- A simple two-dimensional point class -- The underlying mathematics -- Implementing the DistProxy object -- Expanding DistProxy to something more useful -- Comparing distances with DistProxy -- Calculating distances with DistProxy -- Preventing the misuse of DistProxy -- Performance evaluation -- Creative operator overloading and proxy objects -- The pipe operator as an extension method -- The pipe operator -- The infix operator -- Further reading -- Summary -- Chapter 10: Concurrency -- Understanding the basics of concurrency -- What makes concurrent programming hard? -- Concurrency and parallelism -- Time slicing -- Shared memory -- Data races -- Mutex -- Deadlock -- Synchronous and asynchronous tasks -- Concurrent programming in C++ -- The thread support library -- Threads. | |
| 520 | |a C++ is a highly portable language and can be used to write both large-scale applications and performance-critical code. It has evolved over the last few years to become a modern and expressive language. This book will guide you through optimizing the performance of your C++ apps by allowing them to run faster and consume fewer resources on the ... | ||
| 590 | |a O'Reilly |b O'Reilly Online Learning: Academic/Public Library Edition | ||
| 650 | 0 | |a C++ (Computer program language) | |
| 650 | 0 | |a Application software |x Development. | |
| 650 | 6 | |a C++ (Langage de programmation) | |
| 650 | 6 | |a Logiciels d'application |x Développement. | |
| 650 | 7 | |a Application software |x Development |2 fast | |
| 650 | 7 | |a C++ (Computer program language) |2 fast | |
| 856 | 4 | 0 | |u https://learning.oreilly.com/library/view/~/9781787120952/?ar |z Texto completo (Requiere registro previo con correo institucional) |
| 994 | |a 92 |b IZTAP | ||