The C++20 Masterclass : From Fundamentals to Advanced

Welcome
1 Welcome
2 Getting the most out of the course
3 Source code, Slides and Questions [IMPORTANT]

Environment Setup – [Windows – Linux – Mac]
4 The Tools

Environment setup – Windows
5 Windows setup introduction
6 Install and setup VS Code on Windows
7 Microsoft Visual Studio Install – Windows
8 VS Code setup with MSVC
9 Install GCC _ Clang – Windows
10 Configure VS Code for GCC – Windows
11 Configure VS Code for Clang – Windows
12 Windows template project – All compilers
13 Windows Development Environment setup – Summary

Environment setup – Linux
14 Linux environment setup – Introduction
15 Install _ setup VS Code on Linux
16 Install GCC on Linux
17 Configure VS Code for GCC – Linux
18 Install Clang on Linux
19 Configure VS Code for Clang – Linux
20 Template Project – All compilers – Linux

Environment setup – Mac
21 Introduction
22 Install and Setup Visual Studio Code
23 Install GCC and Clang
24 Configure VS Code for gcc
25 Configure VS Code for Clang
26 Template Project – All compilers

Environmet setup – Other options
27 Online Compilers
28 About other IDEs

Diving In
29 Project Template
30 Your First C++ Program
31 Comments
32 Errors
33 Statements and Functions
34 Data input and output
35 C++ Program Execution Model
36 C++ core language Vs Standard library Vs STL
37 Summary

Variables and Data Types
38 Introduction
39 Number Systems
40 Decimals and Integers
41 Integer Modifiers
42 Fractional Numbers
43 Booleans
44 Characters And Text
45 Auto
46 Assignments
47 Summary

Operations on Data
48 Introduction
49 Basic Operations
50 Precedence and Associativity
51 PrefixPostfix Increment _ Decrement
52 Compound Assignment Operators
53 RelationalOperators
54 Logical Operators
55 Output formatting
56 Numeric Limits
57 Math Functions
58 Weird Integral Types
59 Summary

Literals and Constants
60 Introduction
61 Literals
62 Constants
63 Constant Expressions
64 constinit
65 Summary

Data Conversions Overflow _ Underflow
66 Introduction
67 Implicit Data Conversions
68 Explicit Data Conversions
69 Overflow and Underflow
70 Summary

Bitwise Operators
71 Introduction
72 Printing Integers in Binary
73 Shift Operators
74 Logical Bitwise Operators
75 Compound Bitwise and Assignment Operators
76 Masks
77 Mask Example
78 Packing Color Information
79 Summary

Variable Lifetime and Scope
80 Variable Lifetime
81 Variable Scope

Control Flow
82 Introduction
83 If Statements
84 Else If
85 Switch
86 Short Circuit Evaluations
87 Integral Logic Conditions
88 Ternary Operators
89 If constexpr
90 If with Initializer
91 Switch with Initializer
92 Variable Scope Revisited
93 Switch Scope
94 Summary

Loops
95 Introduction
96 For Loop
97 For Loop Multiple Declarations
98 Comma Operator
99 Range Based For Loop
100 While Loop
101 Huge Loops with Output
102 Do while loop
103 Infinite loops
104 Infinite Loops Practice
105 Decrementing Loops
106 Nested Loops
107 Break and Continue
108 Fix the Calculator
109 For Loop with Init condition
110 Summary

Arrays
111 Introduction
112 Declaring and using arrays
113 Size of an array
114 Arrays of characters
115 Array Bounds
116 Generating Random Numbers
117 Fun with character arrays Fortune Teller V1
118 Multi dimensional arrays
119 Multi dimensional arrays of characters
120 Fun with multi dimensional arrays of characters Fortune Teller V2
121 Summary

Pointers
122 Introduction
123 Declaring and using pointers
124 Pointer to char
125 Arrays of pointer to char
126 const pointer and pointer to const
127 Array of const pointer to const char
128 Pointers and arrays
129 Swapping array data A demo
130 Pointer arithmetic Introduction
131 Pointer Arithmetic Navigation
132 Pointer arithmetic Distance between elements
133 Pointer Arithmetic Comparing Pointers
134 Swapping array data Pointer arithmetic
135 Program Memory Map Revisited
136 Dynamic Memory Allocation
137 Dangling Pointers
138 When new fails
139 Null pointer safety
140 Memory Leaks
141 Dynamically allocated arrays
142 Summary

References
143 Introduction
144 Declaring and using references
145 Comparing pointers and references
146 References and const
147 References with Range based for loops
148 Summary

Character manipulation and strings
149 Introduction
150 Character Manipulation
151 C-string manipulation
152 C-String concatenation and copy
153 Introducing stdstring
154 Declaring and using stdstring
155 Concatenating stdstring
156 Accessing Characters in stdstring
157 stdstring size and capacity
158 Modifying stdstring
159 Comparing stdstring_s
160 Comparing with stdstringcompare()
161 stdstring Replacing, copying, resizing and swapping
162 Searching stdstring
163 Transforming stdstring tofrom numbers
164 Escape sequences
165 Raw string literals
166 Copied Strings
167 stdstring_view
168 Summary

Functions
169 Introduction
170 First hand on C++ Functions
171 Function declaration and definitions
172 Multiple Files Revisition the Linker stage
173 Pass by value
174 Pass by const value
175 Pass by pointer
176 Pass by pointer to const
177 Pass by const pointer to const
178 Pass by reference
179 Pass by const reference
180 Passing function parameters Summary
181 Array function parameters
182 Sized array function parameters
183 Passing sized arrays by reference
184 Multi dimensional array function parameter
185 Default function arguments
186 Implicit Conversions
187 Implicit conversions with references
188 Implicit conversions with pointers
189 string_view Parameters
190 Implicit conversions from stdstring_view to stdstring
191 constexpr functions
192 consteval functions
193 Summary

Enums and Type aliases
194 Introduction
195 Enumerated types (Enum Class)
196 using enum
197 Legacy enumerated types
198 Type aliases
199 Summary

Arguments to main
200 Introduction
201 Grab and use the arguments
202 Calculator V1
203 Calculator V2
204 Summary

Getting things out of functions
205 Introduction
206 Input and output parameters
207 Returning from functions (by value)
208 Returning by reference
209 Returning by pointer
210 Returning array element pointer
211 Bare auto type deduction
212 Function return type deduction
213 Return type deduction with references
214 Function definitions with return type deduction
215 Optional output from functions
216 Introducing stdoptional
217 Optional output with stdoptional
218 Summary

Function Overloading
219 Introduction
220 Overloading with different parameters
221 Overloading with pointer parameters
222 Overloading with reference parameters
223 Overloading with const parameters by value
224 Overloading with const pointer and pointer to const parameters
225 Overloading with const references
226 Overloading with default parameters
227 Summary

Lambda Functions
228 Introduction
229 Declaring and using lambda functions
230 Capture lists
231 Capture all in context
232 Summary

Functions The misfits
233 Introduction
234 Static variables
235 Inline functions
236 Recursive Functions
237 Summary

Function call stack and debugging
238 Introduction
239 The call stack
240 Debugging C++ applications
241 Debugging in VS Code
242 Debugging in CodeLite
243 Debugging in Microsoft Visual Studio
244 Debugging arrays, loops and pointers
245 Summary

Function Templates
246 Introduction
247 Trying out function templates
248 Template type deduction and explicit arguments
249 Template parameters by reference
250 Template specialization
251 Function templates with overloading
252 Function template specializations Vs Overloads Some additional reading
253 Function templates with multiple parameters
254 Template return type deduction with auto
255 Decltype and trailing return types
256 Declytpe auto
257 Default arguments
258 Non type template parameters
259 Auto Function Templates
260 Named Template Parameters for Lambdas
261 Type traits
262 constexpr if
263 Summary

C++ 20 Concepts
264 Introduction
265 Using Concepts
266 Building your own concepts
267 Zooming in on the requires clause
268 Combining concepts Conjunction(_) and Disjunction()
269 Concepts and auto
270 Summary

Classes
271 Introduction
272 Your First Class
273 C++ Constructors
274 Defaulted constructors
275 Setters and Getters
276 Class Across Multiple Files
277 Creating classes through IDEs
278 Arrow pointer call notation
279 Destructors
280 Order of Constructor Destructor Calls
281 The this Pointer
282 struct
283 Size of objects
284 Summary

Classes, objects and const
285 Introduction
286 const objects
287 Const objects as function arguments
288 const member functions
289 Getters that work as setters
290 Dangling pointers and references in objects
291 Zooming in on const
292 Mutable Member variables
293 Structured Bindings
294 Summary

Diving deep into constructors and initialization
295 Introduction
296 Default parameters for constructors
297 Initializer lists for constructors
298 Initializer lists Vs Member wise copy initialization
299 Explicit constructors
300 Constructor delegation
301 Copy constructors
302 Objects stored in arrays are copies
303 Shallow Vs Deep copy
304 Move constructors
305 Deleted constructors
306 Initializer list constructors
307 Aggregate Initialization
308 Designated Initializers (C++20)
309 Uniform initializatoin for aggregates
310 Summary

Friends
311 Introduction
312 Friend functions
313 Friend classes
314 Summary

Static members
315 Introduction (theory)
316 Static Members
317 Static member variables
318 Inline static member variables (C++17)
319 Static constants
320 Static constants pre C++17
321 Member variables of self type
322 Member variables of other types
323 Static member functions
324 Nested classes
325 In class member initialization revisited
326 Summary

Namespaces
327 Introduction
328 Creating Namespaces
329 Namespaces Across Multiple Files
330 Default Global Namespace
331 Built In Namespaces
332 Using Declarations
333 Anounymous Namespaces
334 Nested Namespaces
335 Namespace Aliases
336 Summary

Programs with multiple files A closer look
337 Introduction
338 Compiling and linking Compilation Model
339 Declarations and definitions
340 One Definition Rule
341 Linkage
342 Global external variables
343 Flipping linkage
344 Inline variables and functions
345 Inline Vs static (anonymous namespaces)
346 Forward declarations
347 Summary

Smart Pointers
348 Introduction
349 Unique pointers
350 Unique pointers as function parameters and return values
351 Unique pointers and arrays
352 Shared pointers
353 Creating shared pointers from unique pointers
354 Shared pointers with arrays
355 Shared pointers as function parameters and return values
356 Weak pointers
357 Smart pointer members Recommended reading
358 Summary

Operator Overloading
359 Introduction
360 Addition Operator as Member
361 Addition Operator as Non-Member
362 Subscript Operator for Reading
363 Subscript Operator for Reading and Writing
364 Subscript Operator for Collection Types
365 Stream Insertion Operation Operator
366 Stream Extraction Operator
367 Other Arithmetic Operators
368 Compound Operators _ Reusing Other Operators
369 Custom Type Conversions
370 Implicit Conversions with Overriden Binary Operators
371 Unary Prefix Increment Operator As Member
372 Unary Prefix Increment Operator as Non-Member
373 Unary Postfix Increment Operator
374 Prefix-Postfix Decrement Operator (Exercise)
375 Copy Assignment Operator
376 Copy Assignment Operator for Other Types
377 Type Conversions Recap
378 Functors
379 Summary

Logical Operators and C++ 20 Three Way Comparison Infrastructure
380 Introduction
381 All Logical Operators
382 Rel Ops Namespace
383 Logical Operators with Implicit Conversions
384 Three way comparison operator
385 Defaulted Equality Operator
386 Custom equality operator
387 Default ordering with spaceship operator
388 Members without the spaceship operator
389 Custom spaceship operator for ordering
390 Logical Operators Simplified
391 Spaceship operator as a non member
392 Zooming in on weak ordering – Example 1
393 Zooming on weak ordering – Example 2
394 Zooming on partial ordering
395 Summing up on comparisons in C++ 20
396 Summary

Inheritance
397 Introduction
398 First try on Inheritance
399 Protected members
400 Base class access specifiers Zooming in
401 Base class access specifiers A demo
402 Closing in on Private Inheritance
403 Resurecting Members Back in Context
404 Default Constructors with Inheritance
405 Custom Constructors With Inheritance
406 Copy Constructors with Inheritance
407 Inheriting Base Constructors
408 Inheritance and Destructors
409 Reused Symbols in Inheritance
410 Summary

Polymorphism
411 Introduction
412 Static Binding with Inheritance
413 Dynamic binding with virtual functions
414 Size of polymorphic objects and slicing
415 Polymorphic objects stored in collections (array)
416 Override
417 Overloading, overriding and function hiding
418 Inheritance and Polymorphism at different levels
419 Inheritance and polymorphism with static members
420 Final
421 Final and Override are not keywords
422 Polymorphic functions and access specifiers
423 Non polymorphic functions and access specifiers
424 Virtual functions with default arguments
425 Virtual Destructors
426 Dynamic casts
427 Polymorphic Functions and Destructors
428 typeid() operator
429 Pure virtual functions and abstract classes
430 Abstract Classes as Interfaces
431 Summary

Exception Handling
432 Introduction
433 Try and Catch Blocks and scope
434 The need for exceptions
435 Handling Exceptions At Different Levels
436 Multiple Handlers for an Exception
437 Nested Try Blocks
438 Throwing Classs Objects
439 Exceptions as Class Objects with Inheritance Hierarchies
440 Polymorphic Exceptions
441 RethrownExceptions
442 Program custom termination
443 Ellipsis catch all block
444 noexcept Specifier
445 Exceptions in Destructors
446 Standard Exceptions
447 Catching Standard Exceptions
448 Throwing Standard Exceptions
449 Subclassing Standard Exceptions
450 Summary

BoxContainer class Practicing what we know
451 Introduction
452 Constructing and destructing
453 Adding and Expanding
454 Removing Items
455 Other operators (=,+,+=)
456 Zooming out on BoxContainer
457 Storing In Different Types
458 Summary

Class Templates
459 Introduction
460 Your First Class Template
461 Instances Of Class templates
462 Non type template parameters
463 Default Values for template parameters
464 Explicit Template Instantiations
465 Template Specialization
466 Tempate Specialization with select methods
467 Friends of class templates[Theory intro]
468 Friend functions for class templates
469 Stream insertion operator for class templates
470 Class templates with type traits and static asserts
471 Class templates with C++ 20 concepts
472 Built In Concepts
473 Concepts Example #1
474 Concepts Example #2
475 Summary

Move Semantics
476 Introduction
477 Lvalues and Rvalues
478 Rvalue references
479 Moving temporaries around
480 Move constructors and assignment operators
481 Moving Lvalues with stdmove
482 Invalidating pointers after stdmove
483 Move only types
484 Passing by rvalue reference
485 Summary

Function Like Entities
486 Introduction
487 Function Pointers
488 Callback Functions
489 Function Pointer Type Aliases
490 Function Pointer Type Aliases with Templates
491 Functors
492 Standard Functors (in the functional header)
493 Functors with parameters
494 Functors and lambda functions
495 Lambda functions as callbacks
496 Capturing by value under the hood
497 Capturing by reference under the hood
498 Mixin capturing
499 Capturing the this pointer
500 stdfunction
501 Summary

STL, Containers and Iterators
502 Introduction
503 stdvector
504 stdarray
505 Iterators
506 Traversing container subsets with iterators
507 Reverse iterarators
508 Constant iterators
509 Iterator types
510 stdbegin and stdend
511 Summary

Zooming in on STL Containers
512 Introduction
513 Sequence Containers Deque
514 Sequence Containers Forward list
515 Sequence Containers List
516 Sequence containers stdvector revisited
517 Sequence Containers stdarray revisited
518 Associative Containers Intro
519 Associative Containers Pair
520 Associative Containers Set
521 Associative Containres Map
522 Associative Containers Multiset _ multimap
523 Unordered Associative Containers
524 Container Adaptors Intro
525 Container Adaptors Stack
526 Container Adaptors Queue
527 Container Adaptors Priority queue
528 Summary

STL Algorithms
529 Introduction
530 All of
531 for_each
532 max_element and min_element
533 find
534 copy
535 sort
536 Transform
537 Summary

C++20 Ranges and Range Algorithms
538 Introduction
539 Range Algorithms
540 C++ 20 Ranges Library Iterator Pair Algorithms
541 Projections
542 Views and and Range Adaptors
543 View composition and Pipe operator
544 Range Factories
545 Summary

Building Custom Iterators for Your Containers
546 Introduction
547 Iterator Powers
548 Custom Iterator Theory
549 Building Custom Input Iterators
550 Building Custom Output Iterators
551 Building Custom Forward Iterators
552 Building Custom Bidirectional Iterators
553 Building Custom Random Access Iterators
554 Custom Iterators with C++ 20 Ranges and Views
555 Constant Iterators
556 Raw Pointers as Iterators
557 Wrapping Iterators From Other Containers
558 Summary

C++ 20 Coroutines
559 Introduction
560 Coroutine workflow
561 Coroutine keywords
562 Couroutine Infrastructure
563 co_await
564 co_yield
565 co_rerturn
566 Custom Generator Coroutine Type
567 Third Party Generator Type
568 Summary

C++ 20 Modules
569 Introduction
570 Your first module
571 Block exports
572 Separating module interface from implementation (same file)
573 Separating interface from implementatoin (differen files)
574 Multiple implementation files
575 Multiple interface files
576 export import
577 Submodules
578 Module Interface partitions
579 Summary