Modern C++ MCQ Quiz

The auto keyword was repurposed in C++11 for type inference, allowing the compiler to automatically deduce the type of a variable from its initializer.

nullptr was introduced in C++11 to provide a type-safe null pointer constant. Unlike NULL (which is typically defined as 0), nullptr has its own type std::nullptr_t and doesn't implicitly convert to integral types.

Variadic templates allow functions and classes to accept any number of template arguments. This is used extensively in modern C++ libraries, such as std::make_shared and std::tuple.

Smart pointers (std::unique_ptr, std::shared_ptr, std::weak_ptr) automatically manage the lifetime of dynamically allocated objects, preventing memory leaks and simplifying resource management.

C++14 introduced return type deduction for functions, allowing the use of auto as a return type. The compiler deduces the return type from the return statements in the function body.

The [[nodiscard]] attribute indicates that the return value of a function should not be ignored. The compiler will issue a warning if the return value is discarded.

std::variant is a type-safe union that can hold one of several specified types. It provides type-safe access to the stored value through std::visit and other mechanisms.

Structured bindings allow you to declare multiple variables initialized from elements of a tuple, pair, array, or struct. For example: auto [x, y] = std::pair(1, 2);

C++20 introduced coroutines, which are functions that can be suspended and resumed. They are useful for asynchronous programming, generators, and other use cases requiring cooperative multitasking.

The spaceship operator (<=>) performs a three-way comparison, returning a value that indicates whether the first operand is less than, equal to, or greater than the second operand. It can automatically generate all six comparison operators.

All descriptions are correct: std::move unconditionally converts its argument to an rvalue, while std::forward conditionally converts based on the original value category. std::move is used for moving objects, and std::forward is used for perfect forwarding in templates.

A constexpr function is a function that can potentially be evaluated at compile time. If its arguments are constant expressions, it will be evaluated at compile time; otherwise, it will be executed at runtime.

if constexpr allows compile-time conditional compilation. The condition must be a constant expression, and only the branch that matches the condition is compiled, which is particularly useful in template code.

Concepts are named constraints that specify requirements on template parameters. They make templates more readable, provide better error messages, and allow overloading based on constraints.

std::jthread (joining thread) is an improvement over std::thread that automatically joins on destruction and supports cooperative cancellation through a stop token mechanism.