roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Prepare for C++ interviews on the language and the toolchain around it. Covers ownership and lifetime, templates and the STL, concurrency and undefined behavior, and building and testing native code.
566 of 566 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 566 new. 0 cut, outside your plan.
C++ is interviewed where the code runs close to the hardware or the budget is measured in microseconds: game and engine studios, trading and other low-latency shops, embedded and robotics teams, and the groups that build databases, browsers and compilers. A loop usually tests it twice. The coding round is written in C++, and the interviewer watches how you hold memory, iterators and copies while you solve the problem; a language conversation then turns short snippets over until their semantics show. Teams that own their build often add questions on compiling, linking and testing. The conversation runs on small, exact questions. Does this line compile, and what does it print? What is left in a `std::string_view` returned from a function that built its string locally? Why does a `std::vector` copy its elements when it grows if their move constructor is not `noexcept`? Which overload does `f(nullptr)` pick? What may the optimizer assume about a signed addition that could overflow? In the lower bands, getting those right is most of the job: lifetimes, ownership and the special members the compiler writes or deletes. Further up the questions turn into decisions with a cost attached, such as when to take a virtual call out of a hot loop, how to keep a library's ABI stable across compiler upgrades, whether a codebase should allow exceptions at all, and how a benchmark or a sanitizer run shows that a fix worked.
The plan opens on values and the ways C++ refers to them indirectly: the [initialization](/topics/lang-cpp-expressions-initialization) forms, conversions and type deduction, then [pointers and references](/topics/lang-cpp-pointers). Ownership comes straight after, because most later questions are ownership questions underneath. [RAII](/topics/lang-cpp-memory-raii) and the smart pointers lead, then [when an object begins and ends](/topics/lang-cpp-lifetime), with temporaries and alignment, and [moves](/topics/lang-cpp-move-semantics) close the stretch, since a move only makes sense once you know what is handed over and what the source must still allow. With lifetime settled, the plan builds types: overloads and lambdas, the [special members](/topics/lang-cpp-classes) a class gains or loses, then [virtual dispatch](/topics/lang-cpp-oop-polymorphism) and what it costs. [Templates](/topics/lang-cpp-templates) follow classes rather than precede them, because traits, CRTP and constraints are ways of writing those classes and functions once for many types. The standard library then puts all of it to work, and its containers are read above all for their [invalidation rules](/topics/lang-cpp-stl-iterators), the source of many snippet questions. The middle of the plan is about failure. Exceptions and their safety guarantees sit beside [undefined behavior](/topics/lang-cpp-ub), so a recoverable error and a program the compiler is free to miscompile are learned as different things, and [concurrency](/topics/lang-cpp-concurrency) follows, where a data race is one more way into undefined behavior. The plan then leaves the single file behind: the [compilation model](/topics/lang-cpp-build-model) explains headers, linkage, modules and the ABI, which the performance and embedded modules lean on when they discuss inlining, allocation and builds without exceptions or RTTI. [Standard versions](/topics/lang-cpp-modern-features) close the language part, once every feature they date has been met. The last stretch is the toolchain that turns this code into a tested binary. Compilers and the debugger come first, because the warnings, optimization levels and [sanitizers](/topics/dev-gcc-sanitizers) are how you catch what the failure modules described. [CMake](/topics/dev-cmake), with Make and Ninja beneath it, and the package managers come next, where targets, generators and triplets decide what gets built and linked, and the test frameworks end the plan, GoogleTest with its [mocks](/topics/dev-googletest-gmock) and Catch2 with its sections being the two a team usually chooses between.
Arriving from Java, C# or Python, take the opening two groups slowly. Value semantics, references that cannot be reseated and destructors that run at a known point are where habits from garbage-collected languages produce confident wrong answers. If you already write C++ daily, skim the opening and spend the hours on the failure stretch and the compilation model, where experienced engineers are most often caught by a question on the one-definition rule or on a cast that breaks aliasing. If the interview is days away, pull importance in to must know and cut the level range off at the band on the posting; the toolchain groups can wait until the language ones feel routine. With weeks to spare, switch study order to by topics, work down the plan in the printed sequence, and compile every snippet you got wrong until you can say why it behaves as it does. Game engines, graphics and gameplay code sit outside this plan; the [Game Developer roadmap](/roadmaps/game-developer) puts C++ beside them. The algorithm problems of the coding round have their own drill in [Data Structures and Algorithms](/roadmaps/datastructures-and-algorithms).
C++ is interviewed where the code runs close to the hardware or the budget is measured in microseconds: game and engine studios, trading and other low-latency shops, embedded and robotics teams, and the groups that build databases, browsers and compilers. A loop usually tests it twice. The coding round is written in C++, and the interviewer watches how you hold memory, iterators and copies while you solve the problem; a language conversation then turns short snippets over until their semantics show. Teams that own their build often add questions on compiling, linking and testing.
The conversation runs on small, exact questions. Does this line compile, and what does it print? What is left in a std::string_view returned from a function that built its string locally? Why does a std::vector copy its elements when it grows if their move constructor is not noexcept? Which overload does f(nullptr) pick? What may the optimizer assume about a signed addition that could overflow?
In the lower bands, getting those right is most of the job: lifetimes, ownership and the special members the compiler writes or deletes. Further up the questions turn into decisions with a cost attached, such as when to take a virtual call out of a hot loop, how to keep a library's ABI stable across compiler upgrades, whether a codebase should allow exceptions at all, and how a benchmark or a sanitizer run shows that a fix worked.
The plan opens on values and the ways C++ refers to them indirectly: the initialization forms, conversions and type deduction, then pointers and references. Ownership comes straight after, because most later questions are ownership questions underneath. RAII and the smart pointers lead, then when an object begins and ends, with temporaries and alignment, and moves close the stretch, since a move only makes sense once you know what is handed over and what the source must still allow.
With lifetime settled, the plan builds types: overloads and lambdas, the special members a class gains or loses, then virtual dispatch and what it costs. Templates follow classes rather than precede them, because traits, CRTP and constraints are ways of writing those classes and functions once for many types. The standard library then puts all of it to work, and its containers are read above all for their invalidation rules, the source of many snippet questions.
The middle of the plan is about failure. Exceptions and their safety guarantees sit beside undefined behavior, so a recoverable error and a program the compiler is free to miscompile are learned as different things, and concurrency follows, where a data race is one more way into undefined behavior. The plan then leaves the single file behind: the compilation model explains headers, linkage, modules and the ABI, which the performance and embedded modules lean on when they discuss inlining, allocation and builds without exceptions or RTTI. Standard versions close the language part, once every feature they date has been met.
The last stretch is the toolchain that turns this code into a tested binary. Compilers and the debugger come first, because the warnings, optimization levels and sanitizers are how you catch what the failure modules described. CMake, with Make and Ninja beneath it, and the package managers come next, where targets, generators and triplets decide what gets built and linked, and the test frameworks end the plan, GoogleTest with its mocks and Catch2 with its sections being the two a team usually chooses between.
Arriving from Java, C# or Python, take the opening two groups slowly. Value semantics, references that cannot be reseated and destructors that run at a known point are where habits from garbage-collected languages produce confident wrong answers. If you already write C++ daily, skim the opening and spend the hours on the failure stretch and the compilation model, where experienced engineers are most often caught by a question on the one-definition rule or on a cast that breaks aliasing.
If the interview is days away, pull importance in to must know and cut the level range off at the band on the posting; the toolchain groups can wait until the language ones feel routine. With weeks to spare, switch study order to by topics, work down the plan in the printed sequence, and compile every snippet you got wrong until you can say why it behaves as it does.
Game engines, graphics and gameplay code sit outside this plan; the Game Developer roadmap puts C++ beside them. The algorithm problems of the coding round have their own drill in Data Structures and Algorithms.