C++ Performance
Costs you can count instead of guess: copy and move construction proven by an instrumented class, what reserve does and does not remove, by-value versus const& parameters, the returns C++17 actually guarantees to elide, string concatenation, container and algorithm choice, struct layout reasoned about rather than measured, shared_ptr's atomic reference count, and when virtual dispatch is worth its indirection. Every answer here is a count or a printed fact, checked by compiling and running the code - never a clock reading. It is written for someone who has never profiled anything and reasons about speed from folklore - "moves are cheap," "references avoid copies," "virtual is slow" - and needs each claim replaced with something they compiled themselves. No timing, no benchmarks: just what a program can prove about itself.
Who it is for
Has never measured anything.
For someone confident in the language who wants the traps, the edge cases and the interview questions.
You will get the most out of it if you have written C++ recently enough to read it without effort, and have been surprised by it at least once. If you are picking the language up for the first time, start with C++ Essentials and come back to this one.
It is also built for interview preparation: the questions are the ones that get asked because they separate people who have read the documentation from people who have hit the behaviour in production.
How long it takes
90 graded questions at roughly 45 seconds each is about 68 minutes of answering in total.
At the default five questions a day, and because the session mixes in your other courses, expect around 18 days — call it 3 weeks — to see everything once, plus a few weeks of thinning reviews after that before it is all mastered.
A question is mastered on the third correct answer, once the gap between reviews has grown past a week — so a course cannot be finished in a weekend however long you sit with it.
Question mix
- 60 multiple choice
- 10 concept cards
- 10 predict the output
- 10 put it in order
- 10 matching questions
Syllabus
What you will be asked about
-
01
Copies You Did Not Ask For
Count the copies a small program actually makes, using an instrumented class instead of a guess.
-
02
Move vs Copy Cost
Tell a move from a copy by what an instrumented class prints, not by assuming moves are always what runs.
-
03
reserve and Reallocation
Say precisely what reserve removes, and what it deliberately leaves untouched.
-
04
By Value vs const&
Choose a parameter form by what it actually costs, including the cases where by value is the right call.
-
05
Guaranteed Copy Elision
Say which returns C++17 truly guarantees to elide, and which are only likely - and stop counting the ones that are only likely.
-
06
String Concatenation Costs
Count how many intermediate strings each way of building one string actually creates.
-
07
Algorithm Complexity Choices
Pick the container and algorithm the job actually needs, and count the operations that prove it.
-
08
Data Layout
Say what a struct's layout costs in cache terms by reasoning about it, without ever measuring or printing a size.
-
09
shared_ptr Overhead
Say exactly what a shared_ptr costs over a unique_ptr, and when its reference count is actually touched.
-
10
Virtual Dispatch in Hot Paths
Decide when dynamic dispatch is worth its cost, and know what actually removes it.
8 more topics, and all 90 questions
C++ Performance is a Pro course. One subscription opens it and every other course in the catalogue, including the ones still being written.
A question from this course
Copies You Did Not Ask For
What does this print?
#include <iostream>
int copies = 0;
struct Counted {
int id;
Counted(int i) : id(i) {}
Counted(const Counted& o) : id(o.id) { copies++; }
Counted(Counted&& o) noexcept : id(o.id) {}
};
void take(Counted c) {}
int main() {
Counted a(1);
take(a);
std::cout << copies << "\n";
return 0;
}
Show the answer
A 1
A by-value parameter is a fresh object, and building it from an lvalue argument is exactly what the copy constructor is for - it is not something the compiler quietly skips just because the argument is "only" passed to a function. Counted a is untouched by the call; a single copy constructs take's local parameter, so copies reaches 1.
The rest of the track
C++ at every depth
C++ Essentials
Covers value semantics and copies, references versus pointers, const in each position, auto deduction, range-for aliasing, std::string and std::vector basics, overload resolution with default arguments, aggregate initialisation, and stream output - the behaviours that surprise someone who already knows C++'s syntax. Every snippet compiles and runs against a real compiler, so the traps are proven, not just asserted.
C++ Core
Covers copy versus move, the rule of three and five, temporary and reference lifetime, the three initialization forms and their narrowing rules, implicit conversions and explicit, parameters by value and by reference, function-local static storage, slicing on inheritance, virtual dispatch, and RAII. Aimed at someone who already writes C++ daily but has never had the gap between what compiles and what is correct made explicit.
C++ Collections
Every container in the standard library keeps a different, precise promise about growth, ordering and cost - and the surprises show up exactly where those promises are assumed rather than checked. This course puts pressure on comfortable C++: which references a push_back invalidates, why operator[] silently inserts, when a set drops what you gave it, and what emplace really skips that insert does not. It is for someone comfortable writing C++ who has never been made to justify what a container guarantees.
C++ Errors & Edge Cases
Most C++ code you write handles the case where everything works; this course is about what happens when it does not. It covers stack unwinding and destructor order, why catching by reference matters, how noexcept and throwing destructors reach std::terminate, the three tiers of exception safety, RAII versus manual cleanup, std::optional as a sentinel replacement, error codes versus exceptions, checked versus unchecked bounds access, and how a bare rethrow really propagates.
C++ Standard Library
For a reader who reaches for a dependency before checking what the standard library already provides. Works through the C++17 vocabulary types, RAII smart pointers, the algorithms header, iostream formatting, and chrono durations, with every answer checked against what actually compiles and runs.
C++ Idioms
For a reader who already gets C++ syntax but still reaches for a cleanup function, a raw new, or a hand-rolled loop out of habit from Java, C, or Python. Works through RAII replacing manual cleanup, value semantics versus the heap, the standard algorithms a loop is usually reimplementing, parameter passing by const reference, move semantics, scope guards, if constexpr, the rule of zero, argument-dependent lookup and hidden friends, and the reserve-and-emplace patterns that avoid extra copies. Every example compiles and runs, and the questions target the exact point where fluent-but-foreign C++ habits produce working code that is not idiomatic.
C++ Advanced
Templates, forwarding, CRTP, folds, lambda captures, overload resolution and constexpr - the parts of C++ that only bite once a codebase gets large. Every answer here is guaranteed by the standard, not by one compiler's mood on one machine.
C++ Testing
Ten spines on testing C++ the way it actually gets tested: separating a pure decision from its side effect, injecting a dependency instead of reaching for a global, and telling a test double that proves something from one that only looks reassuring. Every graded snippet compiles as a plain program with a tiny check()-style helper - no gtest, no catch2 - and is checked to give the same answer on both x86-64 and arm64. Written for someone who tests the code they wrote rather than the code they meant, and who writes tests that can pass for the wrong reason without noticing.
C++ Interview Questions
Ten spines of the C++ questions that separate people who have read the documentation from people who have hit the behaviour in production: ownership and the Rule of Five, virtual destructors and slicing, shared_ptr cycles, move semantics, const, dispatch, iterator invalidation, initialisation order, and the classic undefined behaviour every interviewer expects you to name. Every snippet compiles and runs the same way twice - the traps here are conceptual, never machine-dependent.
Start C++ Performance
in tomorrow’s session.
Enrol and this course joins your daily five, mixed in with everything else you are studying — 90 questions spread over about 18 days rather than dropped on you at once.
Browse the catalogue