Modern C++ Smart Pointers Mastery Bundle

Master modern C++ memory management with this exclusive bundle featuring two in-depth courses. Learn unique_ptr inside out; then, level up with the shared_ptr and weak_ptr course, exploring smart pointer internals, control blocks, cyclic reference prevention, and thread safety. Perfect for developers eager to write safer, faster, and more maintainable C++ code.

Image14

Course Description

Master modern C++ memory management end to end with this two-course bundle on unique_ptr and shared_ptr/weak_ptr, designed for engineers who want production-grade clarity on ownership, performance, and safety. Progress from confident single-ownership design with unique_ptr to robust shared ownership with shared_ptr and safe observation with weak_ptr, while learning real control-block internals, allocator and deleter mechanics, thread-safety nuances, and techniques to eliminate leaks and data races.

Features

11-hrs On Demand Video

Exclusive 1-on-1 With Instructor

Course Completion Certificate

Priority Q/A

Full Lifetime Access

Community Access

Curriculum

Memory Management with unique_ptr

👨‍🏫 Course Introduction

📞 Exclusive 30-Minute Session

📊 Course Material

📄 Source Code

Introduction to Dynamic Memory Allocation

Using malloc()

Uninitialized Memory

Using calloc()

Using realloc() - I

Using realloc() - II

Using Operator new

new Operator Workflow

Handling new Failure

Using new[] Operator

Placement new - I

Placement new - II

Reallocation - I

Reallocation - II

Introduction

auto_ptr Issues

Introduction

Return Type

Argument - I

Argument - II

Progress Update

Fixing Uninitialized Pointers

Fixing Dangling Pointers & Double Deleter

Exception Safety - I

Exception Safety - II

Containers - I

Containers - II

Deleter Introduction

Deleter Types

Custom Deleter - I

Custom Deleter - II

Custom Deleter - III

Custom Deleter - IV

Custom Deleter - V

std::make_unique

Dynamic Array - I

Dynamic Array - II

Dynamic Array - III

PIMPL - I

PIMPL - II

PIMPL - III

Project Introduction

Game Implementation - I

Object Pool - I

Object Pool - II

Constructors & Modifiers

Observers

Operators

Uninitialized Construction

Deleter Types

constexpr unique_ptr

Course Completion Certificate

Internals of Shared Memory Management with shared_ptr

👨‍🏫 Course Introduction

📞 Exclusive 30-Minute Session

📊 Course Material

📄 Source Code

Introduction

std::shared_ptr Example

Reference Counting

Copy Semantics

Return Type

Arguments - I

Arguments - II

Arguments - III

Quiz

Uninitialized Pointers

Dangling Pointers

Memory Leaks - I

Memory Leaks - II

Containers

Polymorphism - I

Polymorphism - II

Multithreading - I

Multithreading - II

Quiz

Introduction to Control Block

Reference Counting Revisited

Deleter - I

Deleter - II

Managing File Pointer

Managing Win32 File Handle

Managing Win32 ATOM

Managing Dll Handle

Managing POSIX File Descriptor

More Complex Resource Management

Deleter Internals - I

Deleter Internals - II

C Runtime In Dll - I

C Runtime In Dll - II

C Runtime In Static Library

unique_ptr Across Dll Boundary

shared_ptr Across Dll Boundary

Dynamic Array - I

Dynamic Array - II

Conventional Construction - MSVC

Conventional Construction - GCC & Clang

Introducing std::make_shared

std::make_shared Construction

Control Block - I

Control Block - II

Control Block Layout

Ownership Concepts

Shared Ownership - I

Shared Ownership - II

Weak Ownership - I

Weak Ownership - II

Weak Count - I

Weak Count - II

Acquiring Temporary Ownership - I

Acquiring Temporary Ownership - II

Acquiring Temporary Ownership - III

Cyclic Dependency - I

Cyclic Dependency - II

Cyclic Dependency - III

Cyclic Dependency - IV

Using make_shared & weak_ptr - I

Using make_shared & weak_ptr - II

Using make_shared & weak_ptr - III

Course Completion Certificate

Why Do This Course

Write safer C++ by eliminating leaks, double-deletes, and dangling pointers with proven smart‑pointer patterns.

Choose the right ownership model fast, with clear guidance on when to use unique_ptr, shared_ptr, or weak_ptr.

Break reference cycles confidently using weak_ptr, avoiding hidden memory growth in graphs and observer trees.

Apply thread‑safe patterns for passing and sharing objects across threads without data races.

Master custom deleters and RAII to manage files, sockets, and OS handles reliably under failure.

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

View All Products
Image23

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

Yes please, save my details so you can send me educational content that is relevant and helpful.