C++ quiz — 37 questions with answers and explanations

Answer: C

A reference must bind to an object at initialization and cannot be rebound. There are no null references, so using it for function parameters eliminates a whole class of null pointer errors.

Answer: D

Stack objects have scope-bound lifetime and are destroyed automatically when they go out of scope. Objects allocated with new live until they are deleted, so forgetting delete leaks and double delete corrupts the heap.

Answer: C

Because it's very easy to leak: an early return or a thrown exception skips the delete line. Smart pointers tie deallocation to the object's lifetime (RAII), so memory is always returned no matter how the function exits.

Answer: B

A const method promises not to modify the object's state, so it can be called on const objects and const references. This is what makes it possible to pass objects by const reference, the most common parameter-passing style in C++.

Answer: C

The compiler only needs a declaration to process a file; the linking step needs the actual definition. That's why missing-symbol errors appear at link time and usually come without a source location, making them harder to track down.

Answer: B

Use a const reference: no copy is made and it promises not to modify. For small types like integers or pointers, passing by value is cheaper because it avoids one level of indirection.

Answer: D

It manages its own memory, knows its own size, and grows when needed. A raw array passed to a function loses its size information, and a dynamically allocated array must be freed manually.

Answer: B

It manages its own memory, knows its length, and can append to itself. A C-style string must be scanned to its terminating character to find its length, and concatenation or copying operations must be handled by the calling code to ensure a valid, large enough buffer.

Answer: B

The compiler deduces the type from the initializer expression at compile time. This is static type inference, not dynamic typing, so there is no runtime cost and the variable's type never changes later.

Answer: C

The preprocessor inserts the entire file content at the include site, so if a header contains definitions or declarations that may not be repeated, including it multiple times causes errors. The include guard mechanism ensures each header is processed only once per translation unit.

Answer: B

It guarantees resources are released even when a function throws an exception, because the destructor always runs during stack unwinding. This is the foundation of smart pointers, std::lock_guard, and wrapper classes for files or connections.

Answer: A

An exclusive-ownership pointer cannot be copied, only transfers ownership, and carries no counter overhead. A shared pointer maintains a thread-safe reference count, so it costs more and should be used only when ownership is genuinely shared.

Answer: D

Moving takes the source object's resources instead of duplicating data. Returning a large container from a function or inserting it into another container is therefore no longer as expensive as before.

Answer: A

A user-written destructor usually means the class manages a raw resource. The default copy only copies the pointer, so two objects point to the same resource and both free it when destroyed.

Answer: A

This is undefined behavior, and the common symptom is that the derived class's destructor does not run, leaking the resources it manages. A base class used for polymorphism must have a virtual destructor.

Answer: A

The derived class's own data and behavior are sliced off: the variable only has room for the base-class part. The code compiles and produces no runtime error, making this a silent, hard-to-detect bug.

Answer: B

Templates are processed at compile time: the compiler generates a separate instantiation for each type used. There is no runtime cost, but compile time and code size grow with the number of distinct types.

Answer: C

Use a hash table: average constant-time lookup with no ordering cost. A balanced search tree is only worth it when you need ordered key traversal or a tight worst-case guarantee.

Answer: D

The iterator may become invalidated: when the container reallocates, all elements move to new memory and the old iterator points to freed memory. Continuing to use it is undefined behavior, often not failing immediately and thus very hard to track down.

Answer: A

The strong guarantee means if the operation throws, the state stays exactly as it was before the call, with no partial changes. It's the middle of three levels: basic, strong, and nothrow.

Answer: B

It expresses a value that may be absent without needing a pointer or a sentinel value like minus one. The return type makes it explicit that there may be no result, so the caller is forced to check instead of forgetting.

Answer: C

The risk is that the lambda outlives the captured variable: once the original variable goes out of scope, the reference dangles and calling the lambda later is undefined behavior. This is a very common bug with lambdas that run asynchronously.

Answer: C

The function can be evaluated at compile time if all inputs are constants, and the result becomes a constant inlined directly into the code. If the inputs are only known at runtime, it still runs normally as an ordinary function.

Answer: C

Because the compiler is allowed to assume it never happens. On that assumption, the optimizer can delete even the checks the programmer wrote, so the program behaves completely differently from the intent with no warning at all.

Answer: C

Because the elements are contiguous in memory, so when the processor loads one block, the following elements are already in cache. A linked list follows pointers to scattered regions, and each step can be a memory stall.

Answer: D

The program is terminated immediately. The standard library chooses to abort rather than guess whether the programmer wanted to wait or to let the thread run free, since both implicit choices are dangerous.

Answer: A

The mutex is released automatically when leaving scope, even if the function throws or returns early. Forgetting unlock() on such a branch is a classic cause of deadlock.

Answer: C

That's a data race, and the standard treats it as undefined behavior. What makes it dangerous is that the program usually runs fine during testing and only misbehaves under load, so the bug slips into production very easily.

Answer: B

Because the thread can wake up while the condition isn't satisfied: both from spurious wakeups and because another thread already took the data first. So the wait call must sit inside a loop that checks the condition, or take the predicate as an argument.

Answer: C

The intent of the code shows up right in the algorithm's name, and boundary errors like off-by-one are eliminated. Speed is usually equivalent because both are inlined, so the main benefit lies in readability and correctness.

Answer: B

This type erases type information, so the call becomes an indirect call and may require dynamic allocation for the captured state. Passing a lambda through a template parameter lets the compiler inline it and costs nothing.

Answer: D

A scoped type does not implicitly convert to an integer, and member names live in their own scope. This prevents accidentally comparing two different enum types and avoids name clashes with other things in the same scope.

Answer: C

The function has internal linkage: it is visible only in that source file, so two files defining a function with the same name do not conflict at link time. This is also a way to narrow a module's public surface.

Answer: D

The dependency does not propagate to other targets that use this library. It is correct when that library appears only in the implementation; if its types appear in a public header, it must be declared as propagated.

Answer: C

Static linking embeds the library code into the program, so the file is larger but runs without the library being present on the target machine. Dynamic linking loads at runtime, so updating the library does not require rebuilding the program.

Answer: C

It lets you give each component a clear name instead of accessing by position, making the code much easier to read. It is especially handy when iterating a map container, where each element consists of a key and a value.

Answer: A

Strings in C++ store bytes, not characters, so a single accented Vietnamese letter occupies multiple bytes. The returned length is a byte count, and slicing by byte index can cut in the middle of a character, producing corrupted data.