English | MP4 | AVC 1920×1080 | AAC 48KHz 2ch | 7h 42m | 1.04 GB
Write clean, fast, concurrent code with key features of C++ 14, 17, and now 20.
C++ is a multi-paradigm language that lets you solve a problem in different ways, and this course will teach you the best practices.
Furthermore, C++ has been re-invented again. C++2a is the largest extension to the language since C++11, and it almost feels like a new language. Developers who master the new features will be able to write cleaner, faster and concurrent code. In this course, you will learn about the best practices of C++ programming, including project structure, designing interfaces and classes, C++ Core Guidelines, and the most recent language standard. The new features are numerous and cover almost every area of the language: modules let us organize our programs better; concepts help us create cleaner APIs; ranges forever change how we look at containers; concurrency features, such as coroutines, bring parallel and concurrent programming to a whole new level.
You will get plenty of practical experience with short, real-world code examples. By the end of this course, you will be ready to create better software using C++.
Learn
- Take your C++ skills to the next level
- Learn different programming styles
- Get hands-on experience with useful design patterns
- Know the little details that make great C++ programs
- Write safe and performant concurrent code
- Understand some of the most important C++ Core Guidelines
- Be among the first to learn and use modules, concepts, ranges, and coroutines
Table of Contents
Introduction to C++
1 The Course Overview
2 On Programming Paradigms
3 A Brief History with C++
4 On Development Tools
Structuring Projects in C++
5 Structure of C++ Projects
6 Organizing Source Files
7 Improving Compilation Speed
8 Pimpl Idiom
9 Modules in C++ 2a
10 Structuring Modules
Creating Better Interfaces
11 What Makes a Good Interface
12 Providing a Good Abstraction
13 Passing Things Around
14 Enforcing the Contract
15 Interface with Style
16 Application Binary Interface
Going Object-Oriented
17 Class and Structs
18 Constructors and Destructors
19 Copy and Move
20 Designing Class Hierarchies
21 Dual Hierarchy Example
22 Managing Memory
23 Shared Pointer
From Functions to <functional>
24 What Makes a Good Function
25 Arguments and Return Values
26 Going Functional
27 Using Lambdas
28 Compile-Time Evaluation Using constexpr
Writing Generic Code with Templates
29 When to Use Templates
30 Instantiating the Template
31 Specializing the Template
32 Entering Concepts
33 Diving into Concepts
Working with Collections
34 In Search of a Perfect Container
35 Searching and Sorting
36 Manipulating Data
37 Enter Ranges
38 Dive into Ranges
39 More Range Examples
Concurrent Data Access
40 Data Access Modes
41 Synchronization with Atomics
42 Synchronization with Mutexes
43 Synchronization with Condition Variables
44 Parallel STL
Task-Level Parallelism
45 Thread Pools
46 Promise and Future
47 Running Asynchronous Tasks
48 Task Continuation
49 Grouping Tasks with Fork Join
50 Distributing the Work
Introduction to Coroutines
51 What Is a Coroutine
52 Coroutine Mechanics
53 Coroutine Machinery
54 Writing Our First Coroutine
55 Resuming the Coroutine
Dive Deeper into Coroutines
56 Coroutines on a Thread Pool
57 Scheduling a Coroutine
58 Returning Values
59 Adding Syntactic Sugar
60 Implementing Continuations
61 Putting It All Together
C++ Core Guidelines
62 About the Guidelines
63 Enforcing the Guidelines
64 General Guidelines
Resolve the captcha to access the links!