Skip to content
New this month 24 fresh C++, C#, F#, JavaScript, TypeScript and Lua courses just landed. Browse new releases Use code WELCOME10 for 10% off your first order · 14-day refund
WisdomCharms — home
Cart 0 items in cart
Programming Languages Intermediate Save 40%

C++ Intermediate: Move Semantics, RAII and Smart Pointers

Stop copying by accident and start writing C++ that owns its resources correctly.

26 students

AP Created by Ana Petrova

  • Last updated August 2026
  • English
  • 12h 22m of material
  • 93 lessons

What you will learn

8 concrete outcomes

Every bullet below is something you will have built, shipped or be able to explain by the time you finish the last lesson.

  • Trace exactly when copies, moves, temporaries and destructors occur in your own code
  • Write move constructors and move assignment operators that are correct and noexcept
  • Apply the rule of zero, and the rule of five only when a class truly owns a resource
  • Choose between unique_ptr, shared_ptr and weak_ptr from the ownership question, not habit
  • Design function signatures using value, const reference, rvalue reference and span correctly
  • Make containers and constructors exception-safe using the copy-and-swap idiom
  • Find leaks, dangling references and use-after-free with AddressSanitizer and Valgrind
  • Benchmark a hot path and prove that a move-enabled type actually removed the copies

Course curriculum

7 modules · 93 lessons · 12h 22m of material

12 lessons running 1h 34m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

13 lessons running 1h 44m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

14 lessons running 1h 52m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

13 lessons running 1h 42m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

15 lessons running 2h 00m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

12 lessons running 1h 32m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

14 lessons running 1h 52m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

7 modules · 93 lessons

12h 22m total length

Requirements

Short list, and deliberately so. If you meet these you can start today.

  • Working knowledge of C++ syntax, classes and the standard containers
  • A C++20 compiler and a CMake-based project you can build locally
  • Some experience debugging a crash or a memory error, even an unsuccessful attempt

About this course

You can write C++ that compiles and still have no idea when a copy happens, when a temporary is destroyed, or why your class leaks the moment someone puts it in a vector. This course closes that gap. It treats object lifetime as the central idea in C++ and builds everything else, move semantics, smart pointers, exception safety, on top of it.

We start by making copies visible: instrumented types that print every construction, assignment and destruction, so you can watch what the compiler really does with return values, vector growth and function arguments. From there come rvalue references, std::move, the rule of zero and five, copy elision, and why a moved-from object is valid but unspecified. Smart pointers arrive as consequences rather than magic, with unique_ptr, shared_ptr, weak_ptr and the ownership questions each one answers.

The second half applies all of it: writing a small resource-owning container, making it exception-safe, adding move operations, benchmarking copies against moves, and hunting real leaks with AddressSanitizer and Valgrind. You leave able to review a pull request and say precisely why a signature should take a value, a const reference or an rvalue reference.

Topics covered

Frequently asked questions

Still unsure about something? Write to misteryjj100@gmail.com and a human answers, usually the same working day.

You should be able to write a class, use std::vector and compile a multi-file project. If that describes you, the pace will feel right from the first module.

The core is C++20 because that is what most teams compile with today. Where C++23 changes the advice, such as deducing this and std::expected, there is a short note explaining the difference.

No. AddressSanitizer works with Clang and MSVC on Windows too, and the course shows the exact flags for each toolchain. Valgrind sections include a container-based option for Windows users.

Checkout is handled on our provider's secure payment page. The moment your payment clears we email your personal access link and access code to the address you used at checkout, and the same link appears in your account library. There is nothing to install and nothing to wait for.

Email misteryjj100@gmail.com within 14 days of your purchase, quote your order number, and we refund the full amount to your original payment method. No form to fill in and no questions about how much of the course you watched.

What students say

No reviews yet

Nobody has reviewed this course yet, so there is no score to show. Buy it, work through it, and your review could be the one that helps the next developer decide.

Browse the catalog

Your instructor

AP

Ana Petrova

Systems engineer and C++ instructor

  • 206 students taught
  • 9 courses published
  • 4.4 instructor rating
  • C++
  • Systems programming
  • Memory management
  • Concurrency

Ana spent nine years writing real-time C++ for trading infrastructure before moving into teaching full time. She specialises in the parts of the language people quietly avoid: templates, move semantics, custom allocators and the memory model. Her courses are built around profiling sessions on code that is deliberately slow, so every fix is something you measure rather than memorise. She still contributes to two open-source benchmarking libraries.

See every course by Ana Petrova
$89 USD $149 Discounted from $149. You save 40 percent.

One-time payment · lifetime access

The WisdomCharms dispatch

One useful email a week. No fluff, no spam.

New course releases, discount codes before anyone else, and a short, practical breakdown of one technique — a prompt pattern, a C++ idiom, a TypeScript trick — that you can use the same day.

  • Subscriber-only launch pricing
  • Unsubscribe in one click
  • We never sell your address

By subscribing you agree to our Privacy Policy. Questions? Write to misteryjj100@gmail.com.