C++ gives direct control over memory and object lifetime. Almost every interview question is really a lifetime question.
Object lifetime and dangling references, move semantics, RAII, undefined behaviour, template instantiation, and virtual dispatch cost.
Where it shows up: Systems, trading, embedded, graphics, game engines, and performance-critical infrastructure.
Twenty real C++ questions from the library, code snippet included. Nothing here is paraphrased for search engines. It is the same text a signed-in user sees.
#include <type_traits>
template <typename T, typename = void>
struct has_size : std::false_type {};
template <typename T>
struct has_size<T, std::void_t<decltype(std::declval<T>().size())>>
: std::true_type {};template <typename T>
struct MyAlloc {
using value_type = T;
T* allocate(std::size_t n);
void deallocate(T*, std::size_t);
template <typename U> struct rebind { using other = MyAlloc<U>; };
};auto x = 3.14;
auto y = 42;void f(int p[]) {
std::cout << sizeof(p) << " ";
}
int arr[10];
std::cout << sizeof(arr) << " "; // (1)
f(arr); // (2)for (auto e : v) {
// ...
}int a = 10;
int b = 20;
int& r = a;
r = b;
b = 99;std::optional<int> a; // disengaged
bool r = (a < 5);struct Counter {
int value = 0;
int get() const { return value; }
void bump() { ++value; }
};
void show(const Counter& c) {
std::cout << c.get();
c.bump();
}void a(const std::string& s);
void b(std::string& s);auto fwd = [](auto&&... args) {
return g(std::forward<decltype(args)>(args)...);
};#include <memory>
#include <vector>
std::unique_ptr<int> make() {
return std::make_unique<int>(42);
}
int main() {
std::vector<std::unique_ptr<int>> v;
std::unique_ptr<int> p = make();
v.push_back(p);
}template <typename T>
void target(T&&) { /* ... */ }
template <typename T>
void wrap(T&& arg) {
target(std::forward<T>(arg));
target(std::forward<T>(arg));
}
wrap(42);template <typename T>
void f(T&& x);
const int c = 0;
f(c);std::array<std::byte, 1024> buf;
std::pmr::monotonic_buffer_resource res{buf.data(), buf.size()};
void* p1 = res.allocate(64);
res.deallocate(p1, 64);
void* p2 = res.allocate(64);#include <concepts>
void process(std::integral auto x); // (1)
void process(std::signed_integral auto x); // (2)
process(42);template <typename T>
concept HasParts = requires(T t) {
typename T::value_type;
t.begin();
};void process() {} // base case
template <typename T, typename... Rest>
void process(T first, Rest... rest) {
handle(first);
process(rest...); // recurse on tail
}#include <cstdio>
template <typename... Ts>
void print(Ts... xs) {
((std::printf("%d ", xs)), ...);
}
int main() { print(1, 2, 3); }std::vector<int> v{1,2,3,4,5};
auto r = v | std::views::filter([](int n){ return n % 2 == 0; })
| std::views::transform([](int n){ return n * n; });struct A {
A() = default;
A(A&&) noexcept(false) { /* ... */ }
A(const A&) { /* ... */ }
};
std::vector<A> v; // grows past capacityWe keep the correct answer, the explanation and the scoring behind sign-in so the platform stays honest, which is why the answer options and the worked explanation for every C++ question stay behind a free account. Signing in is free and takes a few seconds.
58 distinct C++ topics are tagged across the library. These are the real topic labels stored on the questions, not a hand-written list.
…