The C20 Masterclass From Fundamentals to Advanced

The C20 Masterclass From Fundamentals to Advanced

What you’ll learn

C++ 20
Ranges
Concepts
Modules
Coroutines
C++ 17
C++ 14
C++ 11
C++98
Operator Overlading
classes
variables and data types
Inheritance
Polymorphism
Const correctness
static variables
Class Templates
Exceptions
Move semantics
Stl containers, iterators and algorithms
Function like entities and callbacks
Lambda expressions
Character manipulation and strings
Return value optimization
And much more!

Requirements

Strong drive and willingness to learn
Access to a PC or Mac with an internet connection
I’ll teach you the rest

Description

Welcome to the C++ 20 Masterclass! A course designed to teach you cutting edge modern C++ from the absolute beginning all the way to very advanced topics, the topics you need in areas where C++ is used massively in modern times. Want to be a confident game developer? High performance applications in the financial sector, how about powerful software modules on top of which server systems, network infrastructure, database systems, even operating systems themselves run on top of? Well C++ is the dominant language used in these areas and many more! C++ is the programming language even other programming languages and technologies like NodeJS, PHP, Java, JavaScript and many more are written in.By learning modern C++, you will be setting yourself up for success in writing software that runs devices ranging from bare metal embedded devices,  to mainstream electronic tech products like fridges, toasters, to networking infrastructure like routers and switches, all the way to power plants, manufacturing facilities and medical equipment. C++ is simply everywhere!This course was carefully designed in a way  that it  will make you ready to take on technologies  and industries where C++ is widely used, by teaching you Modern C++ the way it is used in industry, and you will learn and master how to use shiny new features from the latest C++ standard (C++20) like ranges, modules coroutines, concepts, the three way comparison infrastructure and many more features spread out through out chapters and lectures in the course.This course will teach you modern C++ from the absolute beginning all the way to a point where you can use advanced features like function templates, class templates, polymorphism, move semantics, functors , callbacks, STL container, iterators and algorithms, I will even show you how to build iterators for your own collection types, giving you the tools to  plug into the infrastructure provided by the C++ standard library to tune it to your own needs. Here are some of the things you’ll get to master through this course : C++20C++17C++14C++11C++98RangesModulesConceptsCoroutinesClassesVariables and data typesFunctionsInheritancePolymorphismConst correctnessStatic variablesStorage durationLinkageOne Definition ruleOperator OverloadingThree way comparison infrastructureFunction like entitiesMove semanticsSTL containers, iterators and algorithmsAnd much more!By the time you’re done with the course, you will be ready to use modern C++ with standards C++ 11,C++14, C++17 and C++ 20,  but you will also have the tools necessary to read, understand and work with older C++ code bases with C++98 and below out there, making your  C++ skills valuable across a wide range of areas regardless of the C++ standard in use.The course was designed with complete beginners in mind. So if you have never programmed a computer before, don’t worry, I will be with you every step of the way, showing you around, teaching you the tools, constructs and mechanisms necessary to build real C++ projects.Existing C++ developers or experienced developers from other programming languages will also get a lot of value from the course as we cover advanced topics not covered in other online courses and books as far as I can tell. These include things like building  your own iterators, callback functions and many more.Now C++ is a very powerful language used by big companies like Microsoft, Apple, Google, NASA, and many more across a wide range  of products and I can talk about it all day. I am privileged to have been using it in my daily work for the last decade and I am  excited to share my accumulated knowledge with you in this course.If you are serious about learning and mastering cutting edge modern C++, then this course is designed with the skill, the patience and the depth needed to get there as efficiently as possible. Please check some of the preview lectures, and lets get you started with modern C++ development, using C++ 20 as our base standard.

Overview

Section 1: Welcome

Lecture 1 Welcome

Lecture 2 Getting the most out of the course

Lecture 3 About Source Code and Slides

Lecture 4 Got a question ? Help us help YOU!

Section 2: Environment Setup – [Windows – Linux – Mac]

Lecture 5 The Tools

Section 3: Environment setup – Windows

Lecture 6 Windows setup introduction

Lecture 7 Install and setup VS Code on Windows

Lecture 8 Microsoft Visual Studio Install – Windows

Lecture 9 VS Code setup with MSVC

Lecture 10 Install GCC & Clang – Windows

Lecture 11 Configure VS Code for GCC – Windows

Lecture 12 Configure VS Code for Clang – Windows

Lecture 13 Windows template project – All compilers

Lecture 14 Windows Development Environment setup – Summary

Section 4: Environment setup – Linux

Lecture 15 Linux environment setup – Introduction

Lecture 16 Install & setup VS Code on Linux

Lecture 17 Install GCC on Linux

Lecture 18 Configure VS Code for GCC – Linux

Lecture 19 Install Clang on Linux

Lecture 20 Configure VS Code for Clang – Linux

Lecture 21 Template Project – All compilers – Linux

Section 5: Environment setup – Mac

Lecture 22 Introduction

Lecture 23 Install and Setup Visual Studio Code

Lecture 24 Install GCC and Clang

Lecture 25 Configure VS Code for gcc

Lecture 26 Configure VS Code for Clang

Lecture 27 Template Project – All compilers

Section 6: Environmet setup – Other options

Lecture 28 Online Compilers

Lecture 29 About other IDEs

Section 7: Diving In

Lecture 30 Project Template

Lecture 31 Your First C++ Program

Lecture 32 Comments

Lecture 33 Errors

Lecture 34 Statements and Functions

Lecture 35 Data input and output

Lecture 36 C++ Program Execution Model

Lecture 37 C++ core language Vs Standard library Vs STL

Lecture 38 Summary

Section 8: Variables and Data Types

Lecture 39 Introduction

Lecture 40 Number Systems

Lecture 41 Decimals and Integers

Lecture 42 Integer Modifiers

Lecture 43 Fractional Numbers

Lecture 44 Booleans

Lecture 45 Characters And Text

Lecture 46 Auto

Lecture 47 Assignments

Lecture 48 Summary

Section 9: Operations on Data

Lecture 49 Introduction

Lecture 50 Basic Operations

Lecture 51 Precedence and Associativity

Lecture 52 Prefix/Postfix Increment & Decrement

Lecture 53 Compound Assignment Operators

Lecture 54 RelationalOperators

Lecture 55 Logical Operators

Lecture 56 Output formatting

Lecture 57 Numeric Limits

Lecture 58 Math Functions

Lecture 59 Weird Integral Types

Lecture 60 Summary

Section 10: Literals and Constants

Lecture 61 Introduction

Lecture 62 Literals

Lecture 63 Constants

Lecture 64 Constant Expressions

Lecture 65 constinit

Lecture 66 Summary

Section 11: Data Conversions : Overflow & Underflow

Lecture 67 Introduction

Lecture 68 Implicit Data Conversions

Lecture 69 Explicit Data Conversions

Lecture 70 Overflow and Underflow

Lecture 71 Summary

Section 12: Bitwise Operators

Lecture 72 Introduction

Lecture 73 Printing Integers in Binary

Lecture 74 Shift Operators

Lecture 75 Logical Bitwise Operators

Lecture 76 Compound Bitwise and Assignment Operators

Lecture 77 Masks

Lecture 78 Mask Example

Lecture 79 Packing Color Information

Lecture 80 Summary

Section 13: Variable Lifetime and Scope

Lecture 81 Variable Lifetime

Lecture 82 Variable Scope

Section 14: Control Flow

Lecture 83 Introduction

Lecture 84 If Statements

Lecture 85 Else If

Lecture 86 Switch

Lecture 87 Short Circuit Evaluations

Lecture 88 Integral Logic Conditions

Lecture 89 Ternary Operators

Lecture 90 If constexpr

Lecture 91 If with Initializer

Lecture 92 Switch with Initializer

Lecture 93 Variable Scope Revisited

Lecture 94 Switch Scope

Lecture 95 Summary

Section 15: Loops

Lecture 96 Introduction

Lecture 97 For Loop

Lecture 98 For Loop : Multiple Declarations

Lecture 99 Comma Operator

Lecture 100 Range Based For Loop

Lecture 101 While Loop

Lecture 102 Huge Loops with Output

Lecture 103 Do while loop

Lecture 104 Infinite loops

Lecture 105 Infinite Loops Practice

Lecture 106 Decrementing Loops

Lecture 107 Nested Loops

Lecture 108 Break and Continue

Lecture 109 Fix the Calculator

Lecture 110 For Loop with Init condition

Lecture 111 Summary

Section 16: Arrays

Lecture 112 Introduction

Lecture 113 Declaring and using arrays

Lecture 114 Size of an array

Lecture 115 Arrays of characters

Lecture 116 Array Bounds

Lecture 117 Generating Random Numbers

Lecture 118 Fun with character arrays : Fortune Teller V1

Lecture 119 Multi dimensional arrays

Lecture 120 Multi dimensional arrays of characters

Lecture 121 Fun with multi dimensional arrays of characters : Fortune Teller V2

Lecture 122 Summary

Section 17: Pointers

Lecture 123 Introduction

Lecture 124 Declaring and using pointers

Lecture 125 Pointer to char

Lecture 126 Arrays of pointer to char

Lecture 127 const pointer and pointer to const

Lecture 128 Array of const pointer to const char

Lecture 129 Pointers and arrays

Lecture 130 Swapping array data : A demo

Lecture 131 Pointer arithmetic : Introduction

Lecture 132 Pointer Arithmetic : Navigation

Lecture 133 Pointer arithmetic : Distance between elements

Lecture 134 Pointer Arithmetic : Comparing Pointers

Lecture 135 Swapping array data : Pointer arithmetic

Lecture 136 Program Memory Map Revisited

Lecture 137 Dynamic Memory Allocation

Lecture 138 Dangling Pointers

Lecture 139 When new fails

Lecture 140 Null pointer safety

Lecture 141 Memory Leaks

Lecture 142 Dynamically allocated arrays

Lecture 143 Summary

Section 18: References

Lecture 144 Introduction

Lecture 145 Declaring and using references

Lecture 146 Comparing pointers and references

Lecture 147 References and const

Lecture 148 References with Range based for loops

Lecture 149 Summary

Section 19: Character manipulation and strings

Lecture 150 Introduction

Lecture 151 Character Manipulation

Lecture 152 C-string manipulation

Lecture 153 C-String concatenation and copy

Lecture 154 Introducing std::string

Lecture 155 Declaring and using std::string

Lecture 156 Concatenating std::string

Lecture 157 Accessing Characters in std::string

Lecture 158 std::string size and capacity

Lecture 159 Modifying std::string

Lecture 160 Comparing std::string’s

Lecture 161 Comparing with std::string::compare()

Lecture 162 std::string : Replacing, copying, resizing and swapping

Lecture 163 Searching std::string

Lecture 164 Transforming std::string to/from numbers

Lecture 165 Escape sequences

Lecture 166 Raw string literals

Lecture 167 Copied Strings

Lecture 168 std::string_view

Lecture 169 Summary

Section 20: Functions

Lecture 170 Introduction

Lecture 171 First hand on C++ Functions

Lecture 172 Function declaration and definitions

Lecture 173 Multiple Files : Revisition the Linker stage

Lecture 174 Pass by value

Lecture 175 Pass by const value

Lecture 176 Pass by pointer

Lecture 177 Pass by pointer to const

Lecture 178 Pass by const pointer to const

Lecture 179 Pass by reference

Lecture 180 Pass by const reference

Lecture 181 Passing function parameters :Summary

Lecture 182 Array function parameters

Lecture 183 Sized array function parameters

Lecture 184 Passing sized arrays by reference

Lecture 185 Multi dimensional array function parameter

Lecture 186 Default function arguments

Lecture 187 Implicit Conversions

Lecture 188 Implicit conversions with references

Lecture 189 Implicit conversions with pointers

Lecture 190 string_view Parameters

Lecture 191 Implicit conversions from std::string_view to std::string

Lecture 192 constexpr functions

Lecture 193 consteval functions

Lecture 194 Summary

Section 21: Enums and Type aliases

Lecture 195 Introduction

Lecture 196 Enumerated types (Enum Class)

Lecture 197 using enum

Lecture 198 Legacy enumerated types

Lecture 199 Type aliases

Lecture 200 Summary

Section 22: Arguments to main

Lecture 201 Introduction

Lecture 202 Grab and use the arguments

Lecture 203 Calculator V1

Lecture 204 Calculator V2

Lecture 205 Summary

Section 23: Getting things out of functions

Lecture 206 Introduction

Lecture 207 Input and output parameters

Lecture 208 Returning from functions (by value)

Lecture 209 Returning by reference

Lecture 210 Returning by pointer

Lecture 211 Returning array element pointer

Lecture 212 Bare auto type deduction

Lecture 213 Function return type deduction

Lecture 214 Return type deduction with references

Lecture 215 Function definitions with return type deduction

Lecture 216 Optional output from functions

Lecture 217 Introducing std::optional

Lecture 218 Optional output with std::optional

Lecture 219 Summary

Section 24: Function Overloading

Lecture 220 Introduction

Lecture 221 Overloading with different parameters

Lecture 222 Overloading with pointer parameters

Lecture 223 Overloading with reference parameters

Lecture 224 Overloading with const parameters by value

Lecture 225 Overloading with const pointer and pointer to const parameters

Lecture 226 Overloading with const references

Lecture 227 Overloading with default parameters

Lecture 228 Summary

Section 25: Lambda Functions

Lecture 229 Introduction

Lecture 230 Declaring and using lambda functions

Lecture 231 Capture lists

Lecture 232 Capture all in context

Lecture 233 Summary

Section 26: Functions : The misfits

Lecture 234 Introduction

Lecture 235 Static variables

Lecture 236 Inline functions

Lecture 237 Recursive Functions

Lecture 238 Summary

Section 27: Function call stack and debugging

Lecture 239 Introduction

Lecture 240 The call stack

Lecture 241 Debugging C++ applications

Lecture 242 Debugging in VS Code

Lecture 243 Debugging in CodeLite

Lecture 244 Debugging in Microsoft Visual Studio

Lecture 245 Debugging arrays, loops and pointers

Lecture 246 Summary

Section 28: Function Templates

Lecture 247 Introduction

Lecture 248 Trying out function templates

Lecture 249 Template type deduction and explicit arguments

Lecture 250 Template parameters by reference

Lecture 251 Template specialization

Lecture 252 Function templates with overloading

Lecture 253 Function template specializations Vs Overloads : Some additional reading.

Lecture 254 Function templates with multiple parameters

Lecture 255 Template return type deduction with auto

Lecture 256 Decltype and trailing return types

Lecture 257 Declytpe auto

Lecture 258 Default arguments

Lecture 259 Non type template parameters

Lecture 260 Auto Function Templates

Lecture 261 Named Template Parameters for Lambdas

Lecture 262 Type traits

Lecture 263 constexpr if

Lecture 264 Summary

Section 29: C++ 20 Concepts

Lecture 265 Introduction

Lecture 266 Using Concepts

Lecture 267 Building your own concepts

Lecture 268 Zooming in on the requires clause

Lecture 269 Combining concepts : Conjunction(&&) and Disjunction(||)

Lecture 270 Concepts and auto

Lecture 271 Summary

Section 30: Classes

Lecture 272 Introduction

Lecture 273 Your First Class

Lecture 274 C++ Constructors

Lecture 275 Defaulted constructors

Lecture 276 Setters and Getters

Lecture 277 Class Across Multiple Files

Lecture 278 Creating classes through IDEs

Lecture 279 Arrow pointer call notation

Lecture 280 Destructors

Lecture 281 Order of Constructor Destructor Calls

Lecture 282 The this Pointer

Lecture 283 struct

Lecture 284 Size of objects

Lecture 285 Summary

Section 31: Classes, objects and const

Lecture 286 Introduction

Lecture 287 const objects

Lecture 288 Const objects as function arguments

Lecture 289 const member functions

Lecture 290 Getters that work as setters

Lecture 291 Dangling pointers and references in objects

Lecture 292 Zooming in on const

Lecture 293 Mutable Member variables

Lecture 294 Structured Bindings

Lecture 295 Summary

Section 32: Diving deep into constructors and initialization

Lecture 296 Introduction

Lecture 297 Default parameters for constructors

Lecture 298 Initializer lists for constructors

Lecture 299 Initializer lists Vs Member wise copy initialization

Lecture 300 Explicit constructors

Lecture 301 Constructor delegation

Lecture 302 Copy constructors

Lecture 303 Objects stored in arrays are copies

Lecture 304 Shallow Vs Deep copy

Lecture 305 Move constructors

Lecture 306 Deleted constructors

Lecture 307 Initializer list constructors

Lecture 308 Aggregate Initialization

Lecture 309 Designated Initializers (C++20)

Lecture 310 Uniform initializatoin for aggregates

Lecture 311 Summary

Section 33: Friends

Lecture 312 Introduction

Lecture 313 Friend functions

Lecture 314 Friend classes

Lecture 315 Summary

Section 34: Static members

Lecture 316 Introduction (theory)

Lecture 317 Static Members

Lecture 318 Static member variables

Lecture 319 Inline static member variables (C++17)

Lecture 320 Static constants

Lecture 321 Static constants pre C++17

Lecture 322 Member variables of self type

Lecture 323 Member variables of other types

Lecture 324 Static member functions

Lecture 325 Nested classes

Lecture 326 In class member initialization revisited

Lecture 327 Summary

Section 35: Namespaces

Lecture 328 Introduction

Lecture 329 Creating Namespaces

Lecture 330 Namespaces Across Multiple Files

Lecture 331 Default Global Namespace

Lecture 332 Built In Namespaces

Lecture 333 Using Declarations

Lecture 334 Anounymous Namespaces

Lecture 335 Nested Namespaces

Lecture 336 Namespace Aliases

Lecture 337 Summary

Section 36: Programs with multiple files : A closer look

Lecture 338 Introduction

Lecture 339 Compiling and linking : Compilation Model

Lecture 340 Declarations and definitions

Lecture 341 One Definition Rule

Lecture 342 Linkage

Lecture 343 Global external variables

Lecture 344 Flipping linkage

Lecture 345 Inline variables and functions

Lecture 346 Inline Vs static (anonymous namespaces)

Lecture 347 Forward declarations

Lecture 348 Summary

Section 37: Smart Pointers

Lecture 349 Introduction

Lecture 350 Unique pointers

Lecture 351 Unique pointers as function parameters and return values

Lecture 352 Unique pointers and arrays

Lecture 353 Shared pointers

Lecture 354 Creating shared pointers from unique pointers

Lecture 355 Shared pointers with arrays

Lecture 356 Shared pointers as function parameters and return values

Lecture 357 Weak pointers

Lecture 358 Smart pointer members : Recommended reading

Lecture 359 Summary

Section 38: Operator Overloading

Lecture 360 Introduction

Lecture 361 Addition Operator as Member

Lecture 362 Addition Operator as Non-Member

Lecture 363 Subscript Operator for Reading

Lecture 364 Subscript Operator for Reading and Writing

Lecture 365 Subscript Operator for Collection Types

Lecture 366 Stream Insertion Operation Operator

Lecture 367 Stream Extraction Operator

Lecture 368 Other Arithmetic Operators

Lecture 369 Compound Operators && Reusing Other Operators

Lecture 370 Custom Type Conversions

Lecture 371 Implicit Conversions with Overriden Binary Operators

Lecture 372 Unary Prefix Increment Operator As Member

Lecture 373 Unary Prefix Increment Operator as Non-Member

Lecture 374 Unary Postfix Increment Operator

Lecture 375 Prefix-Postfix Decrement Operator (Exercise)

Lecture 376 Copy Assignment Operator

Lecture 377 Copy Assignment Operator for Other Types

Lecture 378 Type Conversions Recap

Lecture 379 Functors

Lecture 380 Summary

Section 39: Logical Operators and C++ 20 Three Way Comparison Infrastructure

Lecture 381 Introduction

Lecture 382 All Logical Operators

Lecture 383 Rel Ops Namespace

Lecture 384 Logical Operators with Implicit Conversions

Lecture 385 Three way comparison operator

Lecture 386 Defaulted Equality Operator

Lecture 387 Custom equality operator

Lecture 388 Default ordering with spaceship operator

Lecture 389 Members without the spaceship operator

Lecture 390 Custom spaceship operator for ordering

Lecture 391 Logical Operators Simplified

Lecture 392 Spaceship operator as a non member

Lecture 393 Zooming in on weak ordering – Example 1

Lecture 394 Zooming on weak ordering – Example 2

Lecture 395 Zooming on partial ordering

Lecture 396 Summing up on comparisons in C++ 20

Lecture 397 Summary

Section 40: Inheritance

Lecture 398 Introduction

Lecture 399 First try on Inheritance

Lecture 400 Protected members

Lecture 401 Base class access specifiers : Zooming in

Lecture 402 Base class access specifiers : A demo

Lecture 403 Closing in on Private Inheritance

Lecture 404 Resurecting Members Back in Context

Lecture 405 Default Constructors with Inheritance

Lecture 406 Custom Constructors With Inheritance

Lecture 407 Copy Constructors with Inheritance

Lecture 408 Inheriting Base Constructors

Lecture 409 Inheritance and Destructors

Lecture 410 Reused Symbols in Inheritance

Lecture 411 Summary

Section 41: Polymorphism

Lecture 412 Introduction

Lecture 413 Static Binding with Inheritance

Lecture 414 Dynamic binding with virtual functions

Lecture 415 Size of polymorphic objects and slicing

Lecture 416 Polymorphic objects stored in collections (array)

Lecture 417 Override

Lecture 418 Overloading, overriding and function hiding

Lecture 419 Inheritance and Polymorphism at different levels

Lecture 420 Inheritance and polymorphism with static members

Lecture 421 Final

Lecture 422 Final and Override are not keywords

Lecture 423 Polymorphic functions and access specifiers

Lecture 424 Non polymorphic functions and access specifiers

Lecture 425 Virtual functions with default arguments

Lecture 426 Virtual Destructors

Lecture 427 Dynamic casts

Lecture 428 Polymorphic Functions and Destructors

Lecture 429 typeid() operator

Lecture 430 Pure virtual functions and abstract classes

Lecture 431 Abstract Classes as Interfaces

Lecture 432 Summary

Section 42: Exception Handling

Lecture 433 Introduction

Lecture 434 Try and Catch Blocks and scope

Lecture 435 The need for exceptions

Lecture 436 Handling Exceptions At Different Levels

Lecture 437 Multiple Handlers for an Exception

Lecture 438 Nested Try Blocks

Lecture 439 Throwing Classs Objects

Lecture 440 Exceptions as Class Objects with Inheritance Hierarchies

Lecture 441 Polymorphic Exceptions

Lecture 442 RethrownExceptions

Lecture 443 Program custom termination

Lecture 444 Ellipsis catch all block

Lecture 445 noexcept Specifier

Lecture 446 Exceptions in Destructors

Lecture 447 Standard Exceptions

Lecture 448 Catching Standard Exceptions

Lecture 449 Throwing Standard Exceptions

Lecture 450 Subclassing Standard Exceptions

Lecture 451 Summary

Section 43: BoxContainer class : Practicing what we know

Lecture 452 Introduction

Lecture 453 Constructing and destructing

Lecture 454 Adding and Expanding

Lecture 455 Removing Items

Lecture 456 Other operators (=,+,+=)

Lecture 457 Zooming out on BoxContainer

Lecture 458 Storing In Different Types

Lecture 459 Summary

Section 44: Class Templates

Lecture 460 Introduction

Lecture 461 Your First Class Template

Lecture 462 Instances Of Class templates

Lecture 463 Non type template parameters

Lecture 464 Default Values for template parameters

Lecture 465 Explicit Template Instantiations

Lecture 466 Template Specialization

Lecture 467 Tempate Specialization with select methods

Lecture 468 Friends of class templates[Theory intro]

Lecture 469 Friend functions for class templates

Lecture 470 Stream insertion operator for class templates

Lecture 471 Class templates with type traits and static asserts

Lecture 472 Class templates with C++ 20 concepts

Lecture 473 Built In Concepts

Lecture 474 Concepts Example #1

Lecture 475 Concepts Example #2

Lecture 476 Summary

Section 45: Move Semantics

Lecture 477 Introduction

Lecture 478 Lvalues and Rvalues

Lecture 479 Rvalue references

Lecture 480 Moving temporaries around

Lecture 481 Move constructors and assignment operators

Lecture 482 Moving Lvalues with std::move

Lecture 483 Invalidating pointers after std::move

Lecture 484 Move only types

Lecture 485 Passing by rvalue reference

Lecture 486 Summary

Section 46: Function Like Entities

Lecture 487 Introduction

Lecture 488 Function Pointers

Lecture 489 Callback Functions

Lecture 490 Function Pointer Type Aliases

Lecture 491 Function Pointer Type Aliases with Templates

Lecture 492 Functors

Lecture 493 Standard Functors (in the header)

Lecture 494 Functors with parameters

Lecture 495 Functors and lambda functions

Lecture 496 Lambda functions as callbacks

Lecture 497 Capturing by value under the hood

Lecture 498 Capturing by reference under the hood

Lecture 499 Mixin capturing

Lecture 500 Capturing the this pointer

Lecture 501 std::function

Lecture 502 Summary

Section 47: STL, Containers and Iterators

Lecture 503 Introduction

Lecture 504 std::vector

Lecture 505 std::array

Lecture 506 Iterators

Lecture 507 Traversing container subsets with iterators

Lecture 508 Reverse iterarators

Lecture 509 Constant iterators

Lecture 510 Iterator types

Lecture 511 std::begin and std::end

Lecture 512 Summary

Section 48: Zooming in on STL Containers

Lecture 513 Introduction

Lecture 514 Sequence Containers : Deque

Lecture 515 Sequence Containers : Forward list

Lecture 516 Sequence Containers : List

Lecture 517 Sequence containers : std::vector revisited

Lecture 518 Sequence Containers : std::array revisited

Lecture 519 Associative Containers : Intro

Lecture 520 Associative Containers : Pair

Lecture 521 Associative Containers : Set

Lecture 522 Associative Containres : Map

Lecture 523 Associative Containers : Multiset & multimap

Lecture 524 Unordered Associative Containers

Lecture 525 Container Adaptors : Intro

Lecture 526 Container Adaptors : Stack

Lecture 527 Container Adaptors: Queue

Lecture 528 Container Adaptors : Priority queue

Lecture 529 Summary

Section 49: STL Algorithms

Lecture 530 Introduction

Lecture 531 All of

Lecture 532 for_each

Lecture 533 max_element and min_element

Lecture 534 find

Lecture 535 copy

Lecture 536 sort

Lecture 537 Transform

Lecture 538 Summary

Section 50: C++20 Ranges and Range Algorithms

Lecture 539 Introduction

Lecture 540 Range Algorithms

Lecture 541 C++ 20 Ranges Library Iterator Pair Algorithms

Lecture 542 Projections

Lecture 543 Views and and Range Adaptors

Lecture 544 View composition and Pipe operator

Lecture 545 Range Factories

Lecture 546 Summary

Section 51: Building Custom Iterators for Your Containers

Lecture 547 Introduction

Lecture 548 Iterator Powers

Lecture 549 Custom Iterator Theory

Lecture 550 Building Custom Input Iterators

Lecture 551 Building Custom Output Iterators

Lecture 552 Building Custom Forward Iterators

Lecture 553 Building Custom Bidirectional Iterators

Lecture 554 Building Custom Random Access Iterators

Lecture 555 Custom Iterators with C++ 20 Ranges and Views

Lecture 556 Constant Iterators

Lecture 557 Raw Pointers as Iterators

Lecture 558 Wrapping Iterators From Other Containers

Lecture 559 Summary

Section 52: C++ 20 Coroutines

Lecture 560 Introduction

Lecture 561 Coroutine workflow

Lecture 562 Coroutine keywords

Lecture 563 Couroutine Infrastructure

Lecture 564 co_await

Lecture 565 co_yield

Lecture 566 co_rerturn

Lecture 567 Custom Generator Coroutine Type

Lecture 568 Third Party Generator Type

Lecture 569 Summary

Section 53: C++ 20 Modules

Lecture 570 Introduction

Lecture 571 Your first module

Lecture 572 Block exports

Lecture 573 Separating module interface from implementation (same file)

Lecture 574 Separating interface from implementatoin (differen files)

Lecture 575 Multiple implementation files

Lecture 576 Multiple interface files

Lecture 577 export import

Lecture 578 Submodules

Lecture 579 Module Interface partitions

Lecture 580 Summary

Aspiring developers,Students and researchers,Existing C++ developers willing to spice up on C++ 20

Course Information:

Udemy | English | 112h 48m | 59.86 GB
Created by: Daniel Gakwaya

You Can See More Courses in the Developer >> Greetings from CourseDown.com