The C++20 Masterclass : From Fundamentals to Advanced 

Welcome

Getting the most out of the course

Source code, Slides and Questions [IMPORTANT]

The Tools

Windows setup introduction

Install and setup VS Code on Windows

Microsoft Visual Studio Install - Windows

VS Code setup with MSVC

Install GCC & Clang - Windows

Configure VS Code for GCC - Windows

Configure VS Code for Clang - Windows

Windows template project - All compilers

Windows Development Environment setup - Summary

Linux environment setup - Introduction

Install & setup VS Code on Linux

Install GCC on Linux

Configure VS Code for GCC - Linux

Install Clang on Linux

Configure VS Code for Clang - Linux

Template Project - All compilers - Linux

Introduction

Install and Setup Visual Studio Code

Install GCC and Clang

Configure VS Code for gcc

Configure VS Code for Clang

Template Project - All compilers

Online Compilers

About other IDEs

So you think you know more about C++, let's find out

Project Template

Your First C++ Program

Comments

Errors

Statements and Functions

Data input and output

Data Output

C++ Program Execution Model

C++ core language Vs Standard library Vs STL

Program Structure

The program wants to know where you live

Summary

Introduction

Number Systems

Decimals and Integers

Integer Modifiers

Fractional Numbers

Declare and initialize variables

Booleans

Characters And Text

Auto

Assignments

Data Representation in memory

Number systems

Auto

Let's see how you'd use your data types

Summary

Introduction

Basic Operations

Precedence and Associativity

Prefix/Postfix Increment & Decrement

Compound Assignment Operators

RelationalOperators

Logical Operators

Output formatting

Numeric Limits

Math Functions

Area of a hexagon

Weird Integral Types

Celcius to Fahrenheit

Area and Volume of a Box

Introduction

Literals

Constants

Constant Expressions

Introduction

Implicit Data Conversions

Explicit Data Conversions

Overflow and Underflow

Introduction

Printing Integers in Binary

Shift Operators

Logical Bitwise Operators

Compound Bitwise and Assignment Operators

Masks

Mask Example

Packing Color Information

Variable Lifetime

Variable Scope

Introduction

If Statements

Else If

Switch

Leap Years

Short Circuit Evaluations

Integral Logic Conditions

Ternary Operators

If constexpr

If with Initializer

Switch with Initializer

Variable Scope Revisited

Switch Scope

Is it even ? Or could it be odd

Will you get the treatment 

Is the day valid

Hunt for a day in the past

Are you completely surrounded

Summary

Introduction

For Loop

So you think you have a better idea about loops in C++? Let's find out!

Can you sum up to 99?

For Loop : Multiple Declarations

Print upper case characters

Comma Operator

Range Based For Loop

Filter in multiples of 3

While Loop

I am stingy! I want to pay as less as possible

Huge Loops with Output

Do while loop

Multiples of 19

Infinite loops

Infinite Loops Practice

Decrementing Loops

Throwing you off 

Nested Loops

Break and Continue

Fix the Calculator

For Loop with Init condition

Year Calendar

Summary

Introduction

Declaring and using arrays

Eliminating duplicates

Size of an array

The collection is sorted

Arrays of characters

Hunt for vowels

Array Bounds

Array bounds. Why care

Generating Random Numbers

Fun with character arrays : Fortune Teller V1

What do we have in common

Multi dimensional arrays

Multi dimensional arrays of characters

Fun with multi dimensional arrays of characters : Fortune Teller V2

The Calculator

Summary

Introduction

Declaring and using pointers

Pointer to char

So you think you know more about pointers now

Arrays of pointer to char

const pointer and pointer to const

Array of const pointer to const char

Pointers and arrays

Where does the big guy live

Swapping array data : A demo

Pointer arithmetic : Introduction

Pointer Arithmetic : Navigation

Shoot forward

Pointer arithmetic : Distance between elements

Finding Nemo : The little guy

Pointer Arithmetic : Comparing Pointers

Swapping array data : Pointer arithmetic

Program Memory Map Revisited

Dynamic Memory Allocation

Dangling Pointers

So you think you know a bit more about dangling pointers? Let's find out!

When new fails

Null pointer safety

Memory Leaks

Dynamically allocated arrays

Merge them

Summary

Introduction

Declaring and using references

Declare your own reference

Comparing pointers and references

What's your pick : pointers ? References 

References and const

Going through references to do stuff

References with Range based for loops

Summary

Introduction

Character Manipulation

How many of them are there

Hunt them down and replace them

C-string manipulation

C-String concatenation and copy

Making sense of the gibrish

Introducing std::string

Declaring and using std::string

Concatenating std::string

Build from raw pieces!

Accessing Characters in std::string

std::string size and capacity

Modifying std::string

Comparing std::string's

Who's the greatest?

Comparing with std::string::compare()

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

Searching std::string

Finding matches

Transforming std::string to/from numbers

Escape sequences

Raw string literals

Escaping stuff

Copied Strings

Strings gone crazy

std::string_view

Summary

Introduction

First hand on C++ Functions

Sum up the digits

Function declaration and definitions

Showing the odds!

Multiple Files : Revisition the Linker stage

Palindromes

Pass by value

Pass by const value

Pass by pointer

Pass by pointer to const

Pass by const pointer to const

Zooming in on function parameters

Pass by reference

Pass by const reference

Pointers, references and const : Throwing you off

Passing function parameters :Summary

Who has character

Array function parameters

Insertion sort - Challenging

Sized array function parameters

Passing sized arrays by reference

Array function parameters : Throwing you off!

Multi dimensional array function parameter

Default function arguments

Implicit Conversions

Implicit conversions with references

Implicit conversions with pointers

Implicit conversions with function parameters : Throwing you off!

string_view Parameters

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

constexpr functions

consteval functions

consteval functions : Throwing you off!

Maximum sub-sequence sum problem - Challenging.

Summary

Introduction

Enumerated types (Enum Class)

Day of the week

Enum classes : Throwing you off

using enum

Legacy enumerated types

Enums : Throwing you off!

Type aliases

Summary

Introduction

Grab and use the arguments

Calculator V1

Calculator V2

Summary

Introduction

Input and output parameters

Even sums

Returning from functions (by value)

Returning by reference

Returning by pointer

Returning stuff : Throwing you off

Returning array element pointer

We messed up

Bare auto type deduction

Function return type deduction

Return type deduction with references

Function definitions with return type deduction

Type deductions : Throwing you off

Optional output from functions

Introducing std::optional

Optional output with std::optional

Optional data : Throwing you off

Summary

Introduction

Overloading with different parameters

Overloading with pointer parameters

Overloading with reference parameters

double, std::string and const char* overloads : Let's go!

Overloading with const parameters by value

Overloading with const pointer and pointer to const parameters

Overloading with const references

Overloading with default parameters

Crazy overloads : Throwing you off!

Summary

Introduction

Declaring and using lambda functions

Capture lists

Capture all in context

Lambdas : Throwing you off!

Summary

Introduction

Static variables

Self Tracking Function

Odd series

Inline functions

Inlined functions : Throwing you off

Recursive Functions

Factorial

Summary

Introduction

The call stack

Debugging C++ applications

Debugging in VS Code

Debugging in CodeLite

Debugging in Microsoft Visual Studio

Debugging arrays, loops and pointers

Summary

Introduction

Trying out function templates

Hunt them down

Template type deduction and explicit arguments

Template type deductions : Throwing you off

Template parameters by reference

Swap'em'up

Template specialization

Find'em const char* 's

Where do specializations go : Throwing you off!

Function templates with overloading

const char* function template overloads

Function template specializations Vs Overloads : Some additional reading

Function templates with multiple parameters

Put'em numbers together!

Template return type deduction with auto

Function templates in multiple files : Throwing you off!

Decltype and trailing return types

decltype and trailing return types : Throwing you off!

Declytpe auto

Default arguments

Non type template parameters

Find'em values!

Auto Function Templates

auto Function Templates : Throwing you off!

Named Template Parameters for Lambdas

Type traits

constexpr if

Summary

Introduction

Using Concepts

Adding stuff up : Throwing you off!

Building your own concepts

Put'em std::strings together!

Making up concepts : Throwing you off!

Zooming in on the requires clause

Combining concepts : Conjunction(&&) and Disjunction

Concepts : Throwing you off!

Put'em different types together!

Concepts and auto

Summary

Introduction

Your First Class

You're a box maker!

Building for the 2D space!

C++ Constructors

Box Constructors

Construct'em Points!

Defaulted constructors

Constructors : Throwing you off!

Setters and Getters

Point printing like a gentleman!

Class Across Multiple Files

Split your boxes in parts.

Creating classes through IDEs

Arrow pointer call notation

Pointers to objects : Throwing you off!

Destructors

Order of Constructor Destructor Calls

The this Pointer

Setter Chains for Points with pointers

Setter Chains for Points with references

struct

struct Vs class : Throwing you off!

Size of objects

Summary

Introduction

const objects

Const objects : Throwing you off!

Const objects as function arguments

Tricky arguments : Throwing you off

const member functions

Fixing up your Point

Getters that work as setters

Kill two birds with one stone

Dangling pointers and references in objects

Tricky return values : Throwing you off!

Zooming in on const

Mutable Member variables

Structured Bindings

Summary

Introduction

Default parameters for constructors

Default Points

Several paths leading to Rome!

Initializer lists for constructors

Build Boxes like a gentleman!

Initializer lists Vs Member wise copy initialization

Explicit constructors

Constructor delegation

Delegated constructor for Box

Tricky constructor delegation chains

Copy constructors

Copy Constructors : Throwing you off!

You're a Point fixer!

Objects stored in arrays are copies

You're a shape observer!

Shallow Vs Deep copy

Move constructors

The need for move constructors

Deleted constructors

Delete your constructor 

Initializer list constructors

Reverser

Aggregate Initialization

Designated Initializers (C++20)

Uniform initializatoin for aggregates

Summary

Introduction

Friend functions

Measuring distances

Friend classes

You're a ShapeFactory maker!

Summary

Introduction (theory)

Static Members

Static member variables

Static Members : Throwing you off!

Count'em Points

Inline static member variables (C++17)

Static constants

Static constants pre C++17

Count Points like a gentleman

Cool Utility

Member variables of self type

Member variables of other types

Static member functions

Static member functions : Throwing you off!

Nested classes

In class member initialization revisited

Summary

Introduction

Creating Namespaces

Use Points like a gentleman

Namespaces Across Multiple Files

Split your points across

Default Global Namespace

Make it global

Built In Namespaces

Using Declarations

Using declarations : Throwing you off!

Anounymous Namespaces

Anonymous namespaces : Throwing you off!

Nested Namespaces

Namespace Aliases

Summary

Introduction

Compiling and linking : Compilation Model

Compiling and Linking : Throwing you off!

Declarations and definitions

Declaration or Definition : Throwing you off!

One Definition Rule

Linkage

Global external variables

Linnkage : Throwing you off!

Flipping linkage

Inline variables and functions

Inline Vs static (anonymous namespaces)

Forward declarations

Summary

Introduction

Unique pointers

Smarth Pointers : Throwing you off!

Release memory like a gentleman!

You can do better!

Unique pointers as function parameters and return values

Tricky parameters : Throwing you off!

Unique pointers and arrays

Shared pointers

Shared pointers : You can do better!

Creating shared pointers from unique pointers

Shared pointers with arrays

Shared pointers as function parameters and return values

Smart Pointers : Throwing you off!

Weak pointers

Smart pointer members : Recommended reading

Smart Pointers conventional wisdom

Summary

Introduction

Addition Operator as Member

operator+ for Multi-dimensional Points

Addition Operator as Non-Member

Adding up strings

Multi-dimensional Points : Non member operator+

Subscript Operator for Reading

Read data like a genteleman

Subscript Operator for Reading and Writing

Subscript Operator for Collection Types

Stream Insertion Operation Operator

You'll print Points!

You'll print your own strings!

Stream Extraction Operator

Other Arithmetic Operators

Compound Operators && Reusing Other Operators

Compound operators : Throwing you off!

operator+= for CU::string

Custom Type Conversions

Implicit Conversions with Overriden Binary Operators

Use CU::strings left and right, like a gentleman.

Unary Prefix Increment Operator As Member

Unary Prefix Increment Operator as Non-Member

Unary Postfix Increment Operator

Prefix-Postfix Decrement Operator (Exercise)

Copy Assignment Operator

Copies : Throwing you off!

CU::string copy assignment operator

Copy Assignment Operator for Other Types

Type Conversions Recap

Functors

Distance function object

Summary

[Optional] Your very own string class

Introduction

All Logical Operators

You'll compare CU::string's

Rel Ops Namespace

Rel Ops going forward

Logical Operators with Implicit Conversions

Compare like a gentleman

Three way comparison operator

operator<=> : Throwing you off!

Defaulted Equality Operator

Are Points equal ? Or not equal ?

Custom equality operator

Are CU::string's equal? : C++20 Mode!

Default ordering with spaceship operator

Default Ordered Points

Members without the spaceship operator

Custom spaceship operator for ordering

Equality and ordering for CU::string

Logical Operators Simplified

Spaceship operator as a non member

Zooming in on weak ordering - Example 1

Zooming on weak ordering - Example 2

Zooming on partial ordering

Summing up on comparisons in C++ 20

Summary

Introduction

First try on Inheritance

You'll fix the hierarchy

Protected members

Member access specifiers : Throwing you off!

Get it to work

Base and Derived : Throwing you off balance!

Base class access specifiers : Zooming in

Base class access specifiers : A demo

Base class access specifiers : Throwing you off!

Closing in on Private Inheritance

Resurecting Members Back in Context

You'll bring them back!

Default Constructors with Inheritance

Mix'em up!

Custom Constructors With Inheritance

Chain'em Constructors

Copy Constructors with Inheritance

Copy construct'em with inheritance

Inheriting Base Constructors

Inherited base constructors : Throwing you off

Inheritance and Destructors

Reused Symbols in Inheritance

Summary

Introduction

Static Binding with Inheritance

Static binding : Throwing you off!

Dynamic binding with virtual functions

Build a dynamic inheritance tree

Help! Help! Weird references here!

Size of polymorphic objects and slicing

Sliced off ? : Throwing you off!

Polymorphic objects stored in collections (array)

Override

Overloading, overriding and function hiding

Tricky Overloads

Tricky Hierarchies : Throwing you off!

Inheritance and Polymorphism at different levels

Inheritance and polymorphism with static members

Static members with inheritance

Final

Final and Override are not keywords

Polymorphic functions and access specifiers

Non polymorphic functions and access specifiers

Virtual functions with default arguments

Virtual Destructors

Dynamic casts

Polymorphic Functions and Destructors

typeid() operator

Pure virtual functions and abstract classes

Abstract Classes as Interfaces

Summary

Introduction

Try and Catch Blocks and scope

Divide like a boss!

The need for exceptions

Handling Exceptions At Different Levels

Lots of levels : Throwing you off!

Multiple Handlers for an Exception

Nested Try Blocks

Nest your errors : Throwing you off!

Throwing Classs Objects

Build your own

Exceptions as Class Objects with Inheritance Hierarchies

Relatives : Throwing you off!

Polymorphic Exceptions

Relatives, again! : Throwing you off!

RethrownExceptions

Program custom termination

Ellipsis catch all block

noexcept Specifier

Exceptions in Destructors

Standard Exceptions

Catching Standard Exceptions

Throwing Standard Exceptions

Read files like a gentleman!

Subclassing Standard Exceptions

Summary

Introduction

Constructing and destructing

Adding and Expanding

Removing Items

Other operators (=,+,+=)

Zooming out on BoxContainer

Storing In Different Types

Summary

Introduction

Your First Class Template

Building your maps!

Instances Of Class templates

Keeping track of your instances : Throwing you off!

Non type template parameters

Multi dimensional points : The swiss army knife class

Compatible points ? : Throwing you off!

Default Values for template parameters

Sane Defaults

Explicit Template Instantiations

Template Specialization

Compare your maps!

Specialized maps : Throwing you off!

Tempate Specialization with select methods

Comparing Maps ? Not again!!

Comparing Maps. Yes. Again! : Throwing you off!

Friends of class templates[Theory intro]

Friend functions for class templates

Stream insertion operator for class templates

Stream insert'em Points!

Stream insert'em Maps!

Class templates with type traits and static asserts

Type traits constrained Maps!

Class templates with C++ 20 concepts

Built In Concepts

Concept constrain your maps!

Concepts Example #1

Concepts Example #2

Making points better to use with operator<<

Summary

Introduction

Move Semantics : What they're all about

Lvalues and Rvalues

Lvalues and Rvalues : Throwing you off!

Rvalue references

Rvalue references : Throwing you off!

Moving temporaries around

Move constructors and assignment operators

Moving from CU::string's

Moving Lvalues with std::move

Invalidating pointers after std::move

Move only types

Passing by rvalue reference

Summary

Introduction

Function Pointers

Collection Sums

Callback Functions

Modifying scores

Function Pointer Type Aliases

Function Pointer Type Aliases with Templates

Functors

Functor score modifiers

Standard Functors (in the header)

Functors with parameters

Color Printer

Functors and lambda functions

Lambda functions as callbacks

Capturing by value under the hood

Capturing by reference under the hood

Mixin capturing

Capturing the this pointer

std::function

scores modifying std::function

Summary

Introduction

std::vector

std::array

Iterators

Traversing container subsets with iterators

Reverse iterarators

Constant iterators

Iterator types

std::begin and std::end

Unions

Summary

Introduction

Sequence Containers : Deque

Sequence Containers : Forward list

Sequence Containers : List

Print positions

Sequence containers : std::vector revisited

Sequence Containers : std::array revisited

Associative Containers : Intro

Associative Containers : Pair

Associative Containers : Set

Associative Containres : Map

Associative Containers : Multiset & multimap

Unordered Associative Containers

Container Adaptors : Intro

Container Adaptors : Stack

Container Adaptors: Queue

Container Adaptors : Priority queue

Summary

Introduction

All of

for_each

max_element and min_element

find

copy

sort

Transform

Summary

MovableStack

Introduction

Range Algorithms

C++ 20 Ranges Library Iterator Pair Algorithms

Projections

Views and and Range Adaptors

View composition and Pipe operator

Range Factories

Summary

Introduction

Iterator Powers

Custom Iterator Theory

Building Custom Input Iterators

Building Custom Output Iterators

Building Custom Forward Iterators

Building Custom Bidirectional Iterators

Building Custom Random Access Iterators

Custom Iterators with C++ 20 Ranges and Views

Constant Iterators

Raw Pointers as Iterators

Wrapping Iterators From Other Containers

Summary

Introduction

Coroutine workflow

Coroutine keywords

Couroutine Infrastructure

co_await

co_yield

co_rerturn

Custom Generator Coroutine Type

Third Party Generator Type

Summary

Introduction

Your First Module

Block Export

Separating the Module Interface from the Implementation(Same File)

Separating the Module Interface from the Implementation(Different Files)

Multiple Implementatyion Files

Multiple Interface Files

Export Import

Sub-Modules

Module Interface Partitions

Custom Class Templates as Modules (BoxContainer)

Modules with Namespaces

Visibility and Reachability

Private Module Fragments

Do's and Don't's

Summary