C++ Topics

Reference –

https://www.udemy.com/course/the-modern-cpp-20-masterclass/

Welcome

Environment Setup – [Windows – Linux – Mac]

Environment setup – Windows

Environment setup – Linux

  • 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

Environment setup – Mac

  • 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

Environment setup – Other options

  • Online Compilers
  • About other IDEs
  • So you think you know more about C++, let’s find out!

Diving In

Variables and Data Types

Operations on Data

Literals and Constants

  • Introduction
  • Literals
  • Constants
  • Constant Expressions
  • constinit
  • So you think you know more about C++? Let’s find out! – 3 questions
  • Summary

Data Conversions : Overflow & Underflow

  • Introduction
  • Implicit Data Conversions
  • Explicit Data Conversions
  • Overflow and Underflow
  • So you think you know a bit more about C++? Let’s find out! – 4 questions
  • Summary

Bitwise Operators

  • Introduction
  • Printing Integers in Binary
  • Shift Operators
  • Logical Bitwise Operators
  • Compound Bitwise and Assignment Operators
  • Masks
  • Mask Example
  • Packing Color Information
  • So you think you know more about C++? Let’s find out! – 8 questions
  • Summary

Variable Lifetime and Scope

  • Variable Lifetime
  • Variable Scope
  • So you think you know a little more about C++? Let’s find out! – 3 questions

Control Flow

  • Introduction
  • If Statements
  • Else If
  • Switch
  • Leap Years – 1 question
  • 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? – 1 question
  • Will you get the treatment ? – 1 question
  • Is the day valid? – 1 question
  • Hunt for a day in the past – 1 question
  • Are you completely surrounded? – 1 question
  • Summary

Loops

  • Introduction
  • So you think you have a better idea about loops in C++? Let’s find out! – 2 questions
  • For Loop
  • Can you sum up to 99? – 1 question
  • For Loop : Multiple Declarations
  • Print upper case characters – 1 question
  • Comma Operator
  • Range Based For Loop
  • Filter in multiples of 3 – 1 question
  • While Loop
  • I am stingy! I want to pay as less as possible – 1 question
  • Huge Loops with Output
  • Do while loop
  • Multiples of 19 – 1 question
  • Infinite loops
  • Infinite Loops Practice
  • Decrementing Loops
  • Throwing you off 🙂 – 1 question
  • Nested Loops
  • Break and Continue
  • Fix the Calculator
  • For Loop with Init condition
  • Year Calendar – 1 question
  • Summary

Arrays

  • Introduction
  • Declaring and using arrays
  • Eliminating duplicates – 1 question
  • Size of an array
  • The collection is sorted – 1 question
  • Arrays of characters
  • Hunt for vowels – 1 question
  • Array Bounds
  • Array bounds. Why care? – 3 questions
  • Generating Random Numbers
  • Fun with character arrays : Fortune Teller V1
  • What do we have in common? – 1 question
  • Multi dimensional arrays
  • Multi dimensional arrays of characters
  • Fun with multi dimensional arrays of characters : Fortune Teller V2
  • The Calculator – 1 question
  • Summary

Pointers

  • Introduction
  • Declaring and using pointers
  • Pointer to char
  • So you think you know more about pointers now? Let’s find out! – 2 questions
  • 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? – 1 question
  • Swapping array data : A demo
  • Pointer arithmetic : Introduction
  • Pointer Arithmetic : Navigation
  • Shoot forward – 1 question
  • Pointer arithmetic : Distance between elements
  • Finding Nemo : The little guy! – 1 question
  • 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! – 3 questions
  • When new fails
  • Null pointer safety
  • Memory Leaks
  • Dynamically allocated arrays
  • Merge them! – 1 question
  • Summary

References

  • Introduction
  • Declaring and using references
  • Declare your own reference – 1 question
  • Comparing pointers and references
  • What’s your pick : pointers ? References ? – 4 questions
  • References and const
  • Going through references to do stuff – 3 questions
  • References with Range based for loops
  • Summary

Character manipulation and strings

  • Introduction
  • Character Manipulation
  • How many of them are there? – 1 question
  • Hunt them down and replace them! – 1 question
  • C-string manipulation
  • C-String concatenation and copy
  • Making sense of the gibrish – 1 question
  • Introducing std::string
  • Declaring and using std::string
  • Concatenating std::string
  • Build from raw pieces! – 1 question
  • Accessing Characters in std::string
  • std::string size and capacity
  • Modifying std::string
  • Comparing std::string’s
  • Who’s the greatest? – 1 question
  • Comparing with std::string::compare()
  • std::string : Replacing, copying, resizing and swapping
  • Searching std::string
  • Finding matches – 1 question
  • Transforming std::string to/from numbers
  • Escape sequences
  • Raw string literals
  • Escaping stuff – 6 questions
  • Copied Strings
  • Strings gone crazy! – 2 questions
  • std::string_view
  • Summary

Functions

  • Introduction
  • First hand on C++ Functions
  • Sum up the digits – 1 question
  • Function declaration and definitions
  • Showing the odds! – 1 question
  • Multiple Files : Revisit on the Linker stage
  • Palindromes! – 1 question
  • 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 – 6 questions
  • Pass by reference
  • Pass by const reference
  • Pointers, references and const : Throwing you off! – 4 questions
  • Passing function parameters :Summary
  • Who has character? – 1 question
  • Array function parameters
  • Insertion sort – Challenging – 1 question
  • Sized array function parameters
  • Passing sized arrays by reference
  • Array function parameters : Throwing you off! – 5 questions
  • 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! – 9 questions
  • string_view Parameters
  • Implicit conversions from std::string_view to std::string
  • constexpr functions
  • consteval functions
  • consteval functions : Throwing you off! – 3 questions
  • Maximum sub-sequence sum problem – Challenging – 1 question
  • Summary

Enums and Type aliases

  • Introduction
  • Enumerated types (Enum Class)
  • Day of the week – 1 question
  • Enum classes : Throwing you off – 5 questions
  • using enum
  • Legacy enumerated types
  • Enums : Throwing you off! – 1 question
  • Type aliases
  • Summary

Arguments to main

  • Introduction
  • Grab and use the arguments
  • Calculator V1
  • Calculator V2
  • Summary

Getting things out of functions

  • Introduction
  • Input and output parameters
  • Even sums – 1 question
  • Returning from functions (by value)
  • Returning by reference
  • Returning by pointer
  • Returning stuff : Throwing you off! – 8 questions
  • Returning array element pointer
  • We messed up! – 1 question
  • Bare auto type deduction
  • Function return type deduction
  • Return type deduction with references
  • Function definitions with return type deduction
  • Type deductions : Throwing you off! – 8 questions
  • Optional output from functions
  • Introducing std::optional
  • Optional output with std::optional
  • Optional data : Throwing you off! – 1 question
  • Summary

Function Overloading

  • Introduction
  • Overloading with different parameters
  • Overloading with pointer parameters
  • Overloading with reference parameters
  • double, std::string and const char* overloads : Let’s go! – 1 question
  • 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! – 5 questions
  • Summary

Lambda Functions

  • Introduction
  • Declaring and using lambda functions
  • Capture lists
  • Capture all in context
  • Lambdas : Throwing you off! – 8 questions
  • Summary

Functions : The misfits

  • Introduction
  • Static variables
  • Self Tracking Function – 1 question
  • Odd series – 1 question
  • Inline functions
  • Inlined functions : Throwing you off – 1 question
  • Recursive Functions
  • Factorial – 1 question
  • Summary

Function call stack and debugging

  • 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

Function Templates

  • Introduction
  • Trying out function templates
  • Hunt them down! – 1 question
  • Template type deduction and explicit arguments
  • Template type deductions : Throwing you off! – 6 questions
  • Template parameters by reference
  • Swap’em’up! – 1 question
  • Template specialization
  • Find’em const char* ‘s – 1 question
  • Where do specializations go : Throwing you off! – 1 question
  • Function templates with overloading
  • const char* function template overloads – 1 question
  • Function template specializations Vs Overloads : Some additional reading.
  • Function templates with multiple parameters
  • Put’em numbers together! – 1 question
  • Template return type deduction with auto
  • Function templates in multiple files : Throwing you off! – 2 questions
  • Decltype and trailing return types
  • decltype and trailing return types : Throwing you off! – 6 questions
  • Declytpe auto
  • Default arguments
  • Non type template parameters
  • Find’em values! – 1 question
  • Auto Function Templates
  • auto Function Templates : Throwing you off! – 4 questions
  • Named Template Parameters for Lambdas
  • Type traits
  • constexpr if
  • Summary

C++ 20 Concepts

  • Introduction
  • Using Concepts
  • Adding stuff up : Throwing you off! – 5 questions
  • Building your own concepts
  • Put’em std::strings together! – 1 question
  • Making up concepts : Throwing you off! – 2 questions
  • Zooming in on the requires clause
  • Combining concepts : Conjunction(&&) and Disjunction(||)
  • Concepts : Throwing you off! – 2 questions
  • Put’em different types together! – 1 question
  • Concepts and auto
  • Summary

Classes

  • Introduction
  • Things to consider when designing a class
  • Class Syntax – Your First C++ Class
  • C++ Constructors
  • Box Constructors – 1 question
  • Construct’em Points! – 1 question
  • Defaulted constructors
  • Constructors : Throwing you off! – 3 questions
  • Setters and Getters
  • Point printing like a gentleman! – 1 question
  • Class Across Multiple Files
  • Split your boxes in parts – 1 question
  • Creating classes through IDEs
  • Arrow pointer call notation
  • Pointers to objects : Throwing you off! – 7 questions
  • Destructors
  • Order of Constructor Destructor Calls
  • The this Pointer
  • Setter Chains for Points with pointers – 1 question
  • Setter Chains for Points with references -1 question
  • struct
  • struct Vs class : Throwing you off! – 1 question
  • Size of objects
  • Summary

Classes, objects and const

  • Introduction
  • const objects
  • Const objects : Throwing you off! – 7 questions
  • Const objects as function arguments
  • Tricky arguments : Throwing you off – 4 questions
  • const member functions
  • Fixing up your Point – 1 question
  • Getters that work as setters
  • Kill two birds with one stone – 1 question
  • Dangling pointers and references in objects
  • Tricky return values : Throwing you off! – 1 question
  • Zooming in on const
  • Mutable Member variables
  • Structured Bindings
  • Summary

Diving deep into constructors and initialization

  • Introduction
  • Default parameters for constructors
  • Default Points – 1 question
  • Several paths leading to Rome! – 2 questions
  • Initializer lists for constructors
  • Build Boxes like a gentleman! – 1 question
  • Initializer lists Vs Member wise copy initialization
  • Explicit constructors
  • Constructor delegation
  • Delegated constructor for Box – 1 question
  • Tricky constructor delegation chains – 1 question
  • Copy constructors
  • Copy Constructors : Throwing you off! – 3 questions
  • You’re a Point fixer! – 1 question
  • Objects stored in arrays are copies
  • You’re a shape observer! – 2 questions
  • Shallow Vs Deep copy
  • Move constructors
  • The need for move constructors – 1 question
  • Deleted constructors
  • Delete your constructor ? – 1 question
  • Initializer list constructors
  • Reverser – 1 question
  • Aggregate Initialization
  • Designated Initializers (C++20)
  • Uniform initialization for aggregates
  • Summary

Friends

  • Introduction
  • Friend functions
  • Measuring distances – 1 question
  • Friend classes
  • You’re a ShapeFactory maker! – 1 question
  • Summary

Static members

  • Introduction (theory)
  • Static Members
  • Static member variables
  • Static Members : Throwing you off! – 7 questions
  • Count’em Points – 1 question
  • Inline static member variables (C++17)
  • Static constants
  • Static constants pre C++17
  • Count Points like a gentleman – 1 question
  • Cool Utility – 1 question
  • Member variables of self type
  • Member variables of other types
  • Static member functions
  • Static member functions : Throwing you off! – 4 questions
  • Nested classes
  • In class member initialization revisited
  • Summary

Namespaces

  • Introduction
  • Creating Namespaces
  • Use Points like a gentleman – 1 question
  • Namespaces Across Multiple Files
  • Split your points across – 1 question
  • Default Global Namespace
  • Make it global – 1 question
  • Built In Namespaces
  • Using Declarations
  • Using declarations : Throwing you off! – 6 questions
  • Anonymous Namespaces
  • Anonymous namespaces : Throwing you off! – 3 questions
  • Nested Namespaces
  • Namespace Aliases
  • Summary

Programs with multiple files : A closer look

  • Introduction
  • Compiling and linking : Compilation Model
  • Compiling and Linking : Throwing you off! – 5 questions
  • Declarations and definitions
  • Declaration or Definition : Throwing you off! – 7 questions
  • One Definition Rule
  • Linkage
  • Global external variables
  • Linkage : Throwing you off! – 3 questions
  • Flipping linkage
  • Inline variables and functions
  • Inline Vs static (anonymous namespaces)
  • Forward declarations
  • Summary

Smart Pointers

  • Introduction
  • Unique pointers
  • Smart Pointers : Throwing you off! – 3 questions
  • Release memory like a gentleman! – 1 question
  • You can do better! – 1 question
  • Unique pointers as function parameters and return values
  • Tricky parameters : Throwing you off! – 1 question
  • Unique pointers and arrays
  • Shared pointer
  • Shared pointers : You can do better! – 1 question
  • Creating shared pointers from unique pointers
  • Shared pointers with arrays
  • Shared pointers as function parameters and return values
  • Smart Pointers : Throwing you off! – 3 questions
  • Weak pointers
  • Smart pointer members : Recommended reading
  • Smart Pointers conventional wisdom – 1 question
  • Summary

Operator Overloading

  • Introduction
  • Addition Operator as Member
  • operator+ for Multi-dimensional Points – 1 question
  • Addition Operator as Non-Member
  • Adding up strings – 1 question
  • Multi-dimensional Points : Non member operator+ – 1 question
  • Subscript Operator for Reading
  • Read data like a gentleman – 1 question
  • Subscript Operator for Reading and Writing
  • Subscript Operator for Collection Types
  • Stream Insertion Operation Operator
  • You’ll print Points! – 1 question
  • You’ll print your own strings! – 1 question
  • Stream Extraction Operator
  • Other Arithmetic Operators
  • Compound Operators && Reusing Other Operators
  • Compound operators : Throwing you off! – 1 question
  • operator+= for CU::string – 1 question
  • Custom Type Conversions
  • Implicit Conversions with Overridden Binary Operators
  • Use CU::strings left and right, like a gentleman – 1 question
  • 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! – 1 question
  • CU::string copy assignment operator – 1 question
  • Copy Assignment Operator for Other Types
  • Type Conversions Recap
  • Functors
  • Distance function object – 1 question
  • Summary
  • [Optional] Your very own string class – 1 question

Logical Operators and C++ 20 Three Way Comparison Infrastructure

  • Introduction
  • All Logical Operators
  • You’ll compare CU::string’s – 1 question
  • Rel Ops Namespace
  • Rel Ops going forward – 1 question
  • Logical Operators with Implicit Conversions
  • Compare like a gentleman – 1 question
  • Three way comparison operator
  • operator<=> : Throwing you off! – 8 questions
  • Defaulted Equality Operator
  • Are Points equal ? Or not equal ? – 1 question
  • Custom equality operator
  • Are CU::string’s equal? : C++20 Mode! – 1 question
  • Default ordering with spaceship operator
  • Default Ordered Points – 1 question
  • Members without the spaceship operator
  • Custom spaceship operator for ordering
  • Equality and ordering for CU::string – 1 question
  • 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

Inheritance

  • Introduction
  • First try on Inheritance
  • You’ll fix the hierarchy – 1 question
  • Protected members
  • Member access specifiers : Throwing you off! – 1 question
  • Get it to work – 1 question
  • Base and Derived : Throwing you off balance! – 5 questions
  • Base class access specifiers : Zooming in
  • Base class access specifiers : A demo
  • Base class access specifiers : Throwing you off! – 6 questions
  • Closing in on Private Inheritance
  • Resurrecting Members Back in Context
  • You’ll bring them back! – 1 question
  • Default Constructors with Inheritance
  • Mix’em up! – 1 question
  • Custom Constructors With Inheritance
  • Chain’em Constructors – 1 question
  • Copy Constructors with Inheritance
  • Copy construct’em with inheritance – 1 question
  • Inheriting Base Constructors
  • Inherited base constructors : Throwing you off – 2 questions
  • Inheritance and Destructors
  • Reused Symbols in Inheritance
  • Summary

Polymorphism

  • Introduction
  • Static Binding with Inheritance
  • Static binding : Throwing you off! – 3 questions
  • Dynamic binding with virtual functions
  • Build a dynamic inheritance tree – 1 question
  • Help! Help! Weird references here! – 1 question
  • Size of polymorphic objects and slicing
  • Sliced off ? : Throwing you off! – 2 questions
  • Polymorphic objects stored in collections (array)
  • Override
  • Overloading, overriding and function hiding
  • Tricky Overloads – 1 question
  • Tricky overloads : Throwing you off – 1 question
  • Tricky Hierarchies : Throwing you off! – 9 questions
  • Inheritance and Polymorphism at different levels
  • Inheritance and polymorphism with static members
  • Static members with inheritance – 1 question
  • 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

Exception Handling

  • Introduction
  • Try and Catch Blocks and scope
  • Divide like a boss! – 1 question
  • Divide like a boss : Throwing you off! – 2 questions
  • The need for exceptions
  • Handling Exceptions At Different Levels
  • Lots of levels : Throwing you off! – 3 questions
  • Multiple Handlers for an Exception
  • Nested Try Blocks
  • Nest your errors : Throwing you off! – 3 questions
  • Throwing Classs Objects
  • Build your own – 1 question
  • Exceptions as Class Objects with Inheritance Hierarchies
  • Relatives : Throwing you off! – 3 questions
  • Polymorphic Exceptions
  • Relatives, again! : Throwing you off! – 2 questions
  • 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! – 1 question
  • Subclassing Standard Exceptions
  • Summary

BoxContainer class : Practicing what we know

  • Introduction
  • Constructing and destructing
  • Adding and Expanding
  • Removing Items
  • Other operators (=,+,+=)
  • Zooming out on BoxContainer
  • Storing In Different Types
  • Summary

Class Templates

  • Introduction
  • Your First Class Template
  • Building your maps! – 1 question
  • Instances Of Class templates
  • Keeping track of your instances : Throwing you off! – 2 questions
  • Non type template parameters
  • Multi dimensional points : The swiss army knife class – 1 question
  • Compatible points ? : Throwing you off!- 1 question
  • Default Values for template parameters
  • Sane Defaults – 1 question
  • Explicit Template Instantiations
  • Template Instantiations : Throwing you off! – 1 question
  • Template Specialization
  • Compare your maps! – 1 question
  • Specialized maps : Throwing you off!
  • Tempate Specialization with select methods
  • Comparing Maps ? Not again!! – 1 question
  • Comparing Maps. Yes. Again! : Throwing you off! – 1 question
  • Friends of class templates[Theory intro]
  • Friend functions for class templates
  • Stream insertion operator for class templates
  • Stream insert’em Points! – 1 question
  • Stream insert’em Maps! – 1 question
  • Class templates with type traits and static asserts
  • Type traits constrained Maps! – 1 question
  • Class templates with C++ 20 concepts
  • Built In Concepts
  • Concept constrain your maps! – 1 question
  • Templates deadly traps : Throwing you off! – 2 questions
  • Concepts Example #1
  • Concepts Example #2
  • Making points better to use with operator<< – 1 question
  • Fixing TinyTpe : Throwing you off! – 1 question
  • Summary

Move Semantics

  • Introduction
  • Move Semantics : What they’re all about – 1 question
  • Lvalues and Rvalues
  • Lvalues and Rvalues : Throwing you off! – 3 questions
  • Rvalue references
  • Rvalue references : Throwing you off! – 1 question
  • Moving temporaries around
  • Move constructors and assignment operators
  • Moving from CU::string’s – 1 question
  • Moving Lvalues with std::move
  • Invalidating pointers after std::move
  • Move only types
  • Passing by rvalue reference
  • Summary

Function Like Entities

  • Introduction
  • Function Pointers
  • Collection Sums – 1 question
  • Callback Functions
  • Modifying scores – 1 question
  • Function Pointer Type Aliases
  • Function Pointer Type Aliases with Templates
  • Functors
  • Functor score modifiers – 1 question
  • Standard Functors (in the <functional> header)
  • Functors with parameters
  • Color Printer – 1 question
  • 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 – 1 question
  • Summary

STL, Containers and Iterators

  • Introduction
  • std::vector
  • std::array
  • Iterators
  • Traversing container subsets with iterators
  • Reverse iterators
  • Constant iterators
  • Iterator types
  • std::begin and std::end
  • Summary

Zooming in on STL Containers

  • Introduction
  • Sequence Containers : Deque
  • Sequence Containers : Forward list
  • Sequence Containers : List
  • Print positions – 1 question
  • Sequence containers : std::vector revisited
  • Sequence Containers : std::array revisited
  • Associative Containers : Intro
  • Associative Containers : Pair
  • Associative Containers : Set
  • Associative Containers : Map
  • Associative Containers : Multiset & multimap
  • Unordered Associative Containers
  • Container Adaptors : Intro
  • Container Adaptors : Stack
  • Container Adaptors: Queue
  • Container Adaptors : Priority queue
  • Summary

STL Algorithms

  • Introduction
  • All of
  • for_each
  • max_element and min_element
  • find
  • copy
  • sort
  • Transform
  • Summary

C++20 Ranges and Range Algorithms

  • Introduction
  • Range Algorithms
  • C++ 20 Ranges Library Iterator Pair Algorithms
  • Projections
  • Views and and Range Adaptors
  • View composition and Pipe operator
  • Range Factories
  • Summary

Building Custom Iterators for Your Containers

  • 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

C++ 20 Coroutines

  • Introduction
  • Coroutine workflow
  • Coroutine keywords
  • Co-routine Infrastructure
  • co_await
  • co_yield
  • co_rerturn
  • Custom Generator Coroutine Type
  • Third Party Generator Type
  • Summary

C++ 20 Modules

  • Introduction
  • Your first module
  • Block exports
  • Separating module interface from implementation (same file)
  • Separating interface from implementation (different files)
  • Multiple implementation files
  • Multiple interface files
  • export import
  • Submodules
  • Module Interface partitions
  • Summary