Every question is hand-checked, every answer comes with an explanation, and your progress builds into a clear picture of where you stand.
Every C++ question shows its code before you answer, so you are reading real C++, not a description of it.
Once you attempt a question you get the reasoning, not just a tick. That matters most on C++, where object lifetime and dangling references, move semantics, raii, undefined behaviour, template instantiation, and virtual dispatch cost.
Progress is tracked per topic across the 58 C++ topics, so revision points at the gaps instead of the whole list.
523 C++ questions right now: 82 easy, 235 medium and 206 hard. That number is read straight from the question table when this page is built, so it is never a rounded marketing figure.
No. Every C++ question, including its code snippet, its difficulty and its topic, is readable without signing in. You need a free account only to submit an answer, see which option is correct, and read the worked explanation. We keep it that way so the platform stays honest about what you actually got right.
Object lifetime and dangling references, move semantics, RAII, undefined behaviour, template instantiation, and virtual dispatch cost.
58 distinct topics are tagged on the C++ questions, including perfect forwarding std::forward, custom allocators, SFINAE and enable_if, multiple and virtual inheritance layout, variadic templates, shared_ptr and weak_ptr. The topic labels come from the questions themselves, so the list matches what you will actually be asked.
Yes. Reading is free and unlimited. A free account unlocks answering, explanations and progress tracking. Pro (₹199 per month) adds AI explanations and AI-graded guesstimates on top; it is not needed to practise C++ MCQs.
Systems, trading, embedded, graphics, game engines, and performance-critical infrastructure.
These are 12 of the 523 C++ questions in the library, pulled live from the question table. The snippet, the difficulty and the topic are all here. The answer options and the explanation are not. Those need a free account.
Object lifetime and dangling references, move semantics, RAII, undefined behaviour, template instantiation, and virtual dispatch cost.
struct A {
A() = default;
A(A&&) noexcept(false) { /* ... */ }
A(const A&) { /* ... */ }
};
std::vector<A> v; // grows past capacity#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);
}We keep the correct answer, the explanation and the scoring behind sign-in so the platform stays honest, which is why the correct option and the worked explanation for every C++ question stay behind a free account. Signing in is free and takes a few seconds.
Systems, trading, embedded, graphics, game engines, and performance-critical infrastructure.