Modern C++ Mastery Bundle
A complete dual-course bundle covering Modern C++ and C++20 development. The first course builds strong foundations in modern C++ design with smart pointers, move semantics, STL, templates, lambdas, concurrency, RAII, and best practices for writing efficient and maintainable applications. The second course focuses on C++20 features including concepts, ranges, coroutines, modules, spans, format library, synchronization primitives, and major language and standard library improvements used in modern production codebases.
Course Description
This comprehensive bundle combines two complete courses designed to take developers from core Modern C++ programming to advanced C++20 development techniques used in contemporary software systems. The training focuses not only on language syntax, but also on design philosophy, performance awareness, memory safety, maintainability, and writing production-quality C++ code.
The Modern C++ portion of the bundle builds a strong foundation in essential concepts such as RAII, smart pointers, move semantics, copy semantics, STL containers, iterators, algorithms, lambdas, templates, exception safety, multithreading, synchronization, and modern class design practices. Along the way, the course explains the reasoning behind modern C++ idioms and demonstrates how the standard library and language features work together to simplify complex software development tasks.
The C++20 section focuses on the most important additions introduced in the language and standard library. Topics include concepts, ranges, coroutines, modules, spans, the format library, calendar and timezone utilities, synchronization primitives, and other major enhancements that improve expressiveness, correctness, and developer productivity. The course emphasizes practical usage, real-world applicability, and how these features integrate into modern codebases.
Throughout the bundle, the focus remains on building conceptual clarity rather than memorizing syntax. The material is designed to help developers write cleaner, safer, more efficient, and more maintainable C++ applications while understanding the architectural thinking behind modern C++ development.
Features
30-hrs On Demand Video
Exclusive 1-on-1 With Instructor
Course Completion Certificate
Priority Q/A
Full Lifetime Access
Community Access
Curriculum
Master C++ From Fundamentals to Modern Features
🧑🏫 Course Introduction
📞 Exclusive 30-Minute Session
📊 Course Material
📄 Source Code
Required Software
Visual Studio 2015 Installation
Visual Studio 2017 Installation
Visual Studio 2019 Installation
Visual Studio 2026 Installation
CodeBlocks Installation
Cevelop Installation
XCode Installation
What is C++
First C++ Program
The C++ Build Process
C++ Types
Basic Console Input/Output
Functions - I
Functions - II
Overview of Debugging in Visual Studio
Uniform Initialization (C++11)
Pointer Type
Practice
Reference Type
Practice
References vs Pointers
const Qualifier
const Qualifier & Compound Types
Practice
Automatic Type Inference (auto) (C++11)
Range-Based For Loop - I (C++11)
Range-Based For Loop - II (C++11)
Function Overloading
Default Function Overloading
Inline Functions
Function Pointers
Namespace
Quiz
Review
Memory Allocation using malloc
Memory Allocation using new
Allocating Dynamic Arrays - I
Allocating Dynamic Arrays - II
Review
Object Oriented Programming Basics
class
Constructor & Destructor
struct
Non-static Data Member Initialization (C++11)
this pointer
Constant Member Functions
State Member Functions
Copy Semantics - I
Copy Semantics - II
Delegating Constructor (C++11)
Default & Deleted Functions (C++11)
Review
Value Categories (C++11)
Move Semantics Basics
Move Semantics Implementation
Rule of 5 & 0
Copy Elision
std::move Function
Quiz
Basic Operators
Assignment Operator
Global Overloaded Operators
Friend Functions
Smart Pointers - I
Smart Pointers - II
Operator Overloading Rules
Type Conversion Overview
Type Conversion - Primitive to User-defined
Type Conversion - User-defined to Primitive
Initialization vs assignment
Review
Raw Pointers
unique_ptr
Sharing Pointers
Sharing std::unique_ptr
std::shared_ptr
Weak Ownership
weak_ptr Internals
Circular Reference
Deleter
Dynamic Arrays
Make Functions
enum - Basics
enum - Scoped Enums (C++11)
Strings in C
Strings in C++
Practice
StringStreams
Practice
User Defined Literals
constexpr (C++11)
Initializer List
Union - I
Union - II
Practice
Reuse
Inheritance & Access Modifiers
Project I
Project II
Project - III Exercise
Project IV
Project V
Project VI
Project VII
Project VIII
Upcasting & Downcasting
RTTI Overview
RTTI Operators
Abstract Class
13. Multiple Inheritance
Review
Basics
Multiple Catch Blocks
Stack Unwinding
Nested Exceptions
Exception Handling in Constructors & Destructors
noexcept Keyword (C++11)
Raw String Literals (C++11)
Filesystem Overview (C++17)
File IO - Part I
File IO - Part II
File IO - Part III
File IO - Part IV
File IO - Part V
Introduction
Argument Deduction & Instantiation
Explicit Specialization
Nontype Template Arguments
Perfect Forwarding - I (C++11)
Perfect Forwarding - II (C++11)
Variadic Templates - I
Variadic Templates II
Fold Expressions - I (C++17)
Fold Expressions - II (C++17)
Fold Expressions - III (C++17)
Fold Expressions - IV (C++17)
Class Templates
Class Explicit Specialization - I
Class Explicit Specialization - II
Partial Specialization
Alias Templates (C++11)
Type Traits (C++11)
Type Traits Suffixes (C++14)
static_assert (C++11)
TypeTraits
StaticAssert
Class Template ArgumentDeduction
Compile-time If - I
Compile-time If - II
Callbacks using Function Pointers
Callbacks using Function Objects
Lambda Expressions
Lambda Expressions - Internals
Capture List - I
Capture List - II
Capture List - III
Generalized Lambda Capture (C++14)
std::function - I
std::function - II
std::bind-I
std::bind - II
std::bind - III
Introduction
array
vector
deque
list
set
map
Unordered Containers - I
Unordered Containers - II
Custom Hash Function
Big O Notation
Algorithms - I
Algorithms II
Container Changes in C++11 - I
Container Changes in C++11 - II
Container Changes in C++11 - III
Container Changes in C++11 - IV
Container Changes in C++11 - V
Concurrency Basics
Thread creation
Passing Arguments
Thread Synchronization
lock_guard
More Thread functions
async - I
async - II
Launch Policies
Future
Promise
Exceptions
Deprecated & Removed Features
Changes
Attributes
Feature Test Macros
ifswitch with Initialization
inline variables
Nested Namespaces
noexcept Change
constexpr Lambda
Structured Bindings
EvaluationOrder
Mandatory Copy Elision - I
Mandatory Copy Elision - II
std::optional - I
std::optional - II
std::optional- III
std::variant - I
std::variant- II
std::variant- III
any
std::string_view - I
std::string_view - II
Filesystem - path
Filesystem - directory_entry
Filesystem - directory functions
Filesystem - permissions
Parallel Algorithms - I
Parallel Algorithms - II
Parallel Algorithms - III
Before you go...
🏅 Course Certificate
Master the full spectrum of the C++20 standard
Course Introduction
C++20 Topics Overview
Compiler Support for C++20
📊 Course Material
📄 Source Code
Designated Initialization - Aggregate Types
Designated Initialization - Examples
Designated Initialization - More Examples
Init- Statement in Range-Based For Loop - I
Init- Statement in Range-Based For Loop - II
char8_t & std:u8string - I
char8_t & std:u8string - II
Structured Bindings Changes
constexpr Changes
Immediate Functions - conseval
Compile-time Initialization - constinit
Conditionally Explicit Constructor - I
Conditionally Explicit Constructor - II
Conditionally Explicit Constructor - III
Non-Type Template Parameteres
Progress Update
Lambda Expressions - Implicit this Capture
Lambda Expressions - Template Parameters - I
Lambda Expressions - Template Parameters - II
Lambda Expressions - Unevaluated Context
[nodiscard] Attribute
New C++20 Attributes
using enum Declaration
Stream Formatting - I
Stream Formatting - II
C++20 Formatting Library
Basic Usage
println Helper Implementation
Format Specification - Type
Format Specification - Fill, Alignment & Width
Format Specification - Number Formatting
Motivation
Basics
Examples
requires Usage
Abbreviated Templates
Requirement Types - I
Requirement Types - II
Custom Concepts
Standard Library Concepts
Build Process Overview
Module Basics
Naming Modules
Module Compilation
Declaration & Definition Separation
Submodules
Partition Modules
Header Units
Module Private Marker
Course Review
Comparison Operators - I
Comparison Operators - II
Three-way Comparison Operator - I
Three-way Comparison Operator - II
Three-way Comparison Operator - III
Three-way Comparison Operator - IV
Synthesized Expressions - I
Synthesized Expressions - II
Comparisons
Equality Operator - I
Equality Operator - II
Equality Operator - III
Ordering Categories
Strong Ordering
Weak Ordering - I
Weak Ordering - II
Partial Ordering - I
Partial Ordering - II
Ordering Summary
Backward Compatibility
Utilities - I
Utilities - II
Utilities - III
Utilities - IV
Summary
Algorithms & Iterators
Ranges Introduction
Ranges Example
Range Concepts - I
Range Concepts - II
Range Concepts - III
Projections - I
Projections - II
Projections - III
Algorithm Return Types - I
Algorithm Return Types - II
Algorithm Return Types - III
Views - I
Views - II
Views - III
More Views
View Composition
Pipelines
Range Factories
Course Review
Subroutines
Coroutines Introduction
Coroutine Example
Coroutine Anatomy
Coroutine Implementation
Coroutine Workflow - I
Coroutine Workflow - II
Coroutine Workflow - III
Return Values (co_return)
Generators (co_yield)
Awaitable
Awaitable Implementation
Awaiter
Awaiter Implementation - I
Awaiter Implementation - II
Awaiter Methods
Coroutine Concurrency - I
Coroutine Concurrency - II
Coroutine Concurrency - III
Exceptions in Coroutines
Initialization Stage Exceptions
Execution Stage Exceptions - I
Execution Stage Exceptions - II
Conclusion
std::jthread
Thread Stop
Latch
Barrier
Semaphores
std::osyncstream
std::source_location
std:span
Span Fixed Extent
Span Dynamic Extent
Spans As Function Parameters
Subspans
std::is_constant_evaluated
std::bind_front
Container Helper Functions
std::erase()/std::erase_if()
std::ssize
std::contains
🏅 Course Certificate
Why Do This Course
Build strong Modern C++ foundations from core language features to advanced design techniques
Learn practical C++20 features used in modern production codebases
Understand the philosophy behind STL containers, algorithms, iterators, and abstractions
Write safer and more maintainable code using RAII, smart pointers, and move semantics
Improve performance awareness with modern concurrency and resource management techniques
Learn through practical examples and real-world programming scenarios
Requirements
- Basic knowledge of C++
- Modern C++ compiler (Visual Studio 2022, gcc 13, clang 17)
Related Products
Additional products that may be relevant to your interests
Instructor
- Hello! I'm Umar Lone
I've educated and mentored students and professionals globally, leveraging over 20 years of experience in C++, Object-Oriented Programming, Design Patterns, and related technologies. My professional background includes significant contributions to C++, Java, and C# projects with esteemed companies, alongside providing specialized project consultation & mentoring.
My current focus is on delivering comprehensive video courses that distill this extensive knowledge. I specialize in transforming intricate concepts into clear, practical, and actionable insights, supported by real-world examples. This approach is designed to equip you with the necessary clarity and confidence for sustained growth and impactful contributions within your projects and career trajectory.
Begin your learning journey with me now and unlock the advanced understanding and practical expertise essential for making a significant impact in your field.
Keep in touch
Subscribe for announcements, new courses & discount coupons
