컴퓨터/IT 개발/프로그래밍 , 컴퓨터/IT IT 해외원서
C++ High Performance Second Edition
소장 | 전자책 정가 | 32,000원 |
---|---|---|
판매가 | 32,000원 |
- 출간 정보
- 2020.12.30. 전자책 출간
- 파일 정보
- 5.0MB
- 541쪽
- ISBN
- 9781839212581
- ECN
- -
리디 접속이 원활하지 않습니다.
강제 새로 고침(Ctrl + F5)이나 브라우저 캐시 삭제를 진행해주세요.
계속해서 문제가 발생한다면 리디 접속 테스트를 통해 원인을 파악하고 대응 방법을 안내드리겠습니다.
테스트 페이지로 이동하기
컴퓨터/IT 개발/프로그래밍 , 컴퓨터/IT IT 해외원서
소장 | 전자책 정가 | 32,000원 |
---|---|---|
판매가 | 32,000원 |
<C++ High Performance Second Edition> A comprehensive guide to help aspiring and professional C++ developers elevate the performance of their apps by allowing them to run faster and consume fewer resources
▶Book Description
C++ High Performance, Second Edition guides you through optimizing the performance of your C++ apps. This allows them to run faster and consume fewer resources on the device they're running on without compromising the readability of your codebase.
The book begins by introducing the C++ language and some of its modern concepts in brief. Once you are familiar with the fundamentals, you will be ready to measure, identify, and eradicate bottlenecks in your C++ codebase. By following this process, you will gradually improve your style of writing code. The book then explores data structure optimization, memory management, and how it can be used efficiently concerning CPU caches.
After laying the foundation, the book trains you to leverage algorithms, ranges, and containers from the standard library to achieve faster execution, write readable code, and use customized iterators. It provides hands-on examples of C++ metaprogramming, coroutines, reflection to reduce boilerplate code, proxy objects to perform optimizations under the hood, concurrent programming, and lock-free data structures. The book concludes with an overview of parallel algorithms.
By the end of this book, you will have the ability to use every tool as needed to boost the efficiency of your C++ projects.
▶What You Will Learn
-Write specialized data structures for performance-critical code
-Use modern metaprogramming techniques to reduce runtime calculations
-Achieve efficient memory management using custom memory allocators
-Reduce boilerplate code using reflection techniques
-Reap the benefits of lock-free concurrent programming
-Gain insights into subtle optimizations used by standard library algorithms
-Compose algorithms using ranges library
-Develop the ability to apply metaprogramming aspects such as constexpr, constraints, and concepts
-Implement lazy generators and asynchronous tasks using C++20 coroutines
▶Key Features
-Updated to C++20 with completely revised code and more content on error handling, benchmarking, memory allocators, and concurrent programming
-Explore the latest C++20 features including concepts, ranges, and coroutines
-Utilize C++ constructs and techniques to carry out effective data structure optimization and memory management
▶Who This Book Is For
If you're a C++ developer looking to improve the efficiency of your code or just keen to upgrade your skills to the next level, this book is for you.
▶What this book covers
- Chapter 1, A Brief Introduction to C++, introduces some important properties of C++, such as zero-cost abstractions, value semantics, const correctness, explicit ownership, and error handling. It also discusses the drawbacks of C++.
- Chapter 2, Essential C++ Techniques, outlines automatic type deduction using auto, lambda functions, move semantics, and error handling.
- Chapter 3, Analyzing and Measuring Performance, will teach you how to analyze algorithmic complexity using big O notation. The chapter also discusses how to profile your code to find hotspots and how to set up performance tests using Google Benchmark.
- Chapter 4, Data Structures, takes you through the importance of structuring data so that it can be accessed quickly. Containers from the standard library, such as std::vector, std::list, std::unordered_map, and std::priority_queue, are introduced. Finally, this chapter demonstrates how to use parallel arrays.
- Chapter 5, Algorithms, introduces the most important algorithms from the standard library. You will also learn how to use iterators and ranges, and how to implement your own generic algorithms.
- Chapter 6, Ranges and Views, will teach you how to compose algorithms using the Ranges library introduced in C++20. You will learn why views from the Ranges library are useful and some benefits of lazy evaluation.
- Chapter 7, Memory Management, focuses on safe and efficient memory management. This includes memory ownership, RAII, smart pointers, stack memory, dynamic memory, and custom memory allocators.
- Chapter 8, Compile-Time Programming, explains metaprogramming techniques using constexpr, consteval, and type traits. You will also learn how to use C++20 concepts and the new Concepts library. Finally, it provides practical examples of metaprogramming use cases, such as reflection.
- Chapter 9, Essential Utilities, will guide you through the Utilities library and how to benefit from types such as std::optional, std::any, and std::variant using compile-time programming techniques.
- Chapter 10, Proxy Objects and Lazy Evaluation, explores how proxy objects can be used to perform under-the-hood optimizations while preserving clean syntax. Additionally, some creative uses of operator-overloading are demonstrated.
- Chapter 11, Concurrency, covers the fundamentals of concurrent programming, including parallel execution, shared memory, data races, and deadlocks. It also includes an introduction to the C++ Thread support library, the Atomic library, and the C++ memory model.
- Chapter 12, Coroutines and Lazy Generators, contains a general introduction to the coroutine abstraction. You will learn how ordinary functions and coroutines are executed on the CPU using the stack and the heap. C++20 stackless coroutines are introduced and you will discover how to solve problems using generators.
- Chapter 13, Asynchronous Programming with Coroutines, introduces concurrent programming using stackless coroutines from C++20 and touches on the subject of asynchronous network programming using Boost.Asio.
- Chapter 14, Parallel Algorithms, starts by showing the complexity of writing parallel algorithms and how to measure their performance. It then demonstrates how to utilize standard library algorithms in a parallel context using execution policies.
▶ Preface
The C++ of today provides programmers with the ability to write expressive and robust code, while still making it possible to target almost any hardware platform, and at the same time meet performance-critical requirements. This makes C++ a unique language. Over the last few years, C++ has turned into a modern language that is more fun to use and has better defaults.
This book aims to give you a solid foundation to write efficient applications, as well as an insight into strategies for implementing libraries in modern C++. I have tried to take a practical approach to explaining how C++ works today, where features from C++17 and C++20 are a natural part of the language, rather than looking at C++ historically.
This second edition was written to cover new features added in C++20. I have included features that I think fit well with the rest of the content and the focus of this book. Naturally, chapters that discuss new features serve more as an introduction and contain fewer best practices and well-proven solutions.
At the time of publishing this book, the compiler support for some C++20 features presented is still experimental. If you read this book near to the publication date, the chances are that you will have to wait for some features to become fully supported by your compiler.
Many chapters span a wide range of difficulty. They start with the absolute basics and end with advanced topics such as custom memory allocators. If a section is not relevant to you, feel free to skip it or come back to it later. Apart from the first three chapters, most chapters can be read independently.
Our main technical reviewer, Timur Doumler, has had a big impact on this new edition. His enthusiasm and brilliant feedback have led to some chapters from the first edition being reworked to explain topics more thoroughly and in more depth. Timur has also been a vital contributor when it comes to incorporating new C++20 features into the chapters where they fit naturally. Select parts of the book have also been reviewed by Arthur O'Dwyer, Marius Bancila, and Lewis Baker. It has been a true pleasure to have had such excellent reviewers on this project. I hope you enjoy reading this new edition as much as I have enjoyed writing it.
▶About the Author
- Bjorn Andrist
Bjorn Andrist is a freelance software consultant currently focusing on audio applications. For more than 15 years, he has been working professionally with C++ in projects ranging from UNIX server applications to real-time audio applications on desktop and mobile. In the past, he has also taught courses in algorithms and data structures, concurrent programming, and programming methodologies. Bjorn holds a BS in computer engineering and an MS in computer science from KTH Royal Institute of Technology.
- Viktor Sehr
Viktor Sehr is the founder and main developer of the small game studio Toppluva AB. At Toppluva he develops a custom graphics engine which powers the open-world skiing game Grand Mountain Adventure. He has 13 years of professional experience using C++, with real-time graphics, audio, and architectural design as his focus areas. Through his career, he has developed medical visualization software at Mentice and Raysearch Laboratories as well as real-time audio applications at Propellerhead Software. Viktor holds an M.S. in media science from Linkoping University.
▶TABLE of CONTENTS
-Chapter 1: A Brief Introduction to C++
-Chapter 2: Essential C++ Techniques
-Chapter 3: Analyzing and Measuring Performance
-Chapter 4: Data Structures
-Chapter 5: Algorithms
-Chapter 6: Ranges and Views
-Chapter 7: Memory Management
-Chapter 8: Compile-Time Programming
-Chapter 9: Essential Utilities
-Chapter 10: Proxy Objects and Lazy Evaluation
-Chapter 11: Concurrency
-Chapter 12: Coroutines and Lazy Generators
-Chapter 13: Asynchronous Programming with Coroutines
-Chapter 14: Parallel Algorithms
0.0 점
0명이 평가함
내가 남긴 별점 0.0
별로예요
그저 그래요
보통이에요
좋아요
최고예요
'구매자' 표시는 리디에서 유료도서 결제 후 다운로드 하시거나 리디셀렉트 도서를 다운로드하신 경우에만 표시됩니다.
성인 인증 안내
성인 재인증 안내
청소년보호법에 따라 성인 인증은 1년간
유효하며, 기간이 만료되어 재인증이 필요합니다.
성인 인증 후에 이용해 주세요.
해당 작품은 성인 인증 후 보실 수 있습니다.
성인 인증 후에 이용해 주세요.
청소년보호법에 따라 성인 인증은 1년간
유효하며, 기간이 만료되어 재인증이 필요합니다.
성인 인증 후에 이용해 주세요.
해당 작품은 성인 인증 후 선물하실 수 있습니다.
성인 인증 후에 이용해 주세요.
본문 끝 최상단으로 돌아가기
무료이용권을 사용하시겠습니까?
사용 가능 : 장
<>부터 총 화
무료이용권으로 대여합니다.
무료이용권으로
총 화 대여 완료했습니다.
남은 작품 : 총 화 (원)
C++ High Performance Second Edition
작품 제목
대여 기간 : 일
작품 제목
결제 금액 : 원
결제 가능한 리디캐시, 포인트가 없습니다.
리디캐시를 충전하시면 자동으로 결제됩니다.
최대 5% 리디포인트 적립 혜택도 놓치지 마세요!
이미 구매한 작품입니다.
작품 제목
원하는 결제 방법을 선택해주세요.
작품 제목
대여 기간이 만료되었습니다.
다음화를 보시겠습니까?