C++ MCQ

Explanation

C++ source files commonly use the .cpp extension. .cc, .cxx, and .C are also accepted by many compilers.

Explanation

#include <iostream> provides std::cout, std::cin, and std::cerr for I/O operations.

Explanation

cout stands for "character output" and is used with the << insertion operator to write to standard output.

Explanation

C++ uses primitive type keywords: int, double, char, bool, etc. followed by the variable name.

Explanation

Every C++ program starts execution from the main() function. It returns int (typically 0 on success).

Explanation

:: is the scope resolution operator. std::cout uses it to access cout from the std namespace.

Explanation

A pointer stores the memory address of another variable. Declared as int* ptr; and dereferenced with *ptr.

Explanation

int& ref = x declares a reference (alias). int* ptr = &x declares a pointer holding the address of x.

Explanation

A reference is an alias; it must be initialized when declared and cannot be reseated to refer to a different variable.

Explanation

new allocates memory and calls the constructor. The memory must be freed with delete (or delete[] for arrays).

Explanation

C++ allows multiple functions with the same name as long as they differ in parameter types or count.

Explanation

The class keyword defines a class. The main difference from struct is that class members are private by default.

Explanation

Class members are private by default. Struct members are public by default.

Explanation

Destructors (~ClassName()) are called automatically when an object is destroyed, used to release heap memory, file handles, etc.

Explanation

virtual methods are dispatched at runtime through a vtable, enabling polymorphism when calling through a base class pointer or reference.

Explanation

virtual void draw() = 0; declares a pure virtual function. Classes with pure virtual functions are abstract and cannot be instantiated.

Explanation

void show() const; guarantees the function won't modify the object's state. It can be called on const objects.

Explanation

Templates allow writing type-generic functions and classes. template<typename T> T max(T a, T b) works for any comparable type T.

Explanation

The Standard Template Library provides generic containers (vector, map, set), algorithms (sort, find), and iterators.

Explanation

std::vector<T> is a dynamic array with O(1) random access and amortized O(1) push_back.

Explanation

#include is a preprocessor directive that copies the contents of the specified file into the source file before compilation.

Explanation

Stack memory is allocated/freed automatically with function calls. Heap memory persists until explicitly freed with delete, enabling dynamic lifetimes.

Explanation

namespace myLib { ... } groups related names. using namespace std; brings all std names into scope.

Explanation

endl inserts '\n' and calls flush(). Use '\n' for just a newline without flushing, which is faster in tight loops.

Explanation

The C++ standard says bool is at least 1 byte (to be addressable). Its exact size is implementation-defined but typically 1 byte.

Explanation

Operator overloading lets you define + for your class: Vector operator+(const Vector& other) const.

Explanation

MyClass(const MyClass& other) is called when passing by value or initializing from an existing object. If not defined, the compiler generates a shallow copy.

Explanation

this is an implicit pointer available in non-static member functions, pointing to the object on which the method is called.

Explanation

class Dog : public Animal means Dog inherits Animal's public and protected members.

Explanation

delete ptr; calls the destructor and frees the memory. delete[] arr; must be used for arrays allocated with new[].

Explanation

struct and class are nearly identical in C++. The only difference is default access: struct defaults to public, class to private.

Explanation

static data members are shared across all objects. Static member functions can be called without an instance and cannot access non-static members.

Explanation

inline is a suggestion (not a command) to the compiler. Modern compilers often inline regardless of the keyword based on optimization flags.

Explanation

The range-based for (for (auto x : v)) iterates over all elements, using begin() and end() iterators internally.

Explanation

nullptr is the C++11 null pointer constant of type std::nullptr_t. It's safer than NULL or 0 because it doesn't convert to int.

Explanation

auto x = 3.14; deduces x as double. auto reduces verbosity, especially with iterators and complex template types.

Explanation

const int MAX = 10; prevents MAX from being modified. The compiler enforces this at compile time.

Explanation

void increment(int& x) { x++; } modifies the original variable. No copy is made; the parameter is an alias for the argument.

Explanation

std::string from <string> provides safe string handling. C-style char arrays (char[]) are lower-level and require manual null-termination.

Explanation

Memory leaks occur when new is called without a matching delete. Over time, leaked memory accumulates until the system runs out of resources.

Explanation

RAII ensures resources (memory, files, locks) are released when an object goes out of scope. Smart pointers and std::lock_guard implement RAII.

Explanation

Smart pointers (unique_ptr, shared_ptr, weak_ptr) use RAII to automatically delete objects when no longer needed, preventing memory leaks.

Explanation

unique_ptr is zero-overhead exclusive ownership. shared_ptr maintains a reference count and deletes the object when the count reaches 0.

Explanation

Move constructors (MyClass(MyClass&&)) steal resources from rvalues, enabling efficient transfers without expensive copies (e.g., std::vector reallocation).

Explanation

lvalues persist beyond an expression (you can take their address). rvalues are temporaries. Move semantics and && references exploit rvalues.

Explanation

std::move(x) is a cast to rvalue reference. It signals "I no longer need x," allowing move constructors/assignment to transfer resources efficiently.

Explanation

template<> void swap<std::string>(std::string& a, std::string& b) provides a custom implementation for std::string while the generic template handles all other types.

Explanation

Each class with virtual functions has a vtable. Each object has a vptr pointing to its class's vtable. Virtual calls are resolved via indirection through the vtable.

Explanation

The Rule of Five extends the Rule of Three (destructor, copy ctor, copy assignment) with move constructor and move assignment, for proper resource management.

Explanation

SFINAE enables conditional template instantiation. If template substitution fails (e.g., a type lacks a method), that overload is removed from consideration without a compile error.

Explanation

std::enable_if<std::is_integral<T>::value, T>::type restricts a template to integral types, removing non-matching specializations from overload resolution.

Explanation

template<typename T> void wrapper(T&& arg) { target(std::forward<T>(arg)); } forwards lvalues as lvalues and rvalues as rvalues, avoiding unnecessary copies.

Explanation

[&](int x) { return x + y; } is a lambda capturing y by reference. [=] captures by value. The compiler generates a closure class.

Explanation

constexpr int factorial(int n) { ... } may be evaluated at compile time when called with a constant argument, producing zero runtime overhead.

Explanation

std::optional<T> (C++17) holds either a T or nothing. Check with .has_value() and access with .value() or operator*.

Explanation

auto [x, y] = point; binds the members of point. Works with arrays, std::pair, std::tuple, and aggregates.

Explanation

template<typename... Args> void log(Args&&... args) accepts any number of type arguments. The ... pack expansion applies the operation to each argument.

Explanation

weak_ptr does not increase the reference count. Convert to shared_ptr with lock() to access the object. Used to break shared_ptr reference cycles.

Explanation

UB examples: signed integer overflow, null pointer dereference, out-of-bounds access. UB allows compilers to make optimizing assumptions that can break seemingly correct code.

Explanation

void f() noexcept; guarantees no exception escapes. If one does, std::terminate is called. noexcept enables compiler optimizations, especially for move operations.

Explanation

Named Return Value Optimization (NRVO) and Return Value Optimization (RVO) are forms of copy elision guaranteed by C++17, constructing the object directly in the caller's storage.

Explanation

string_view is a lightweight (pointer + length) view into an existing string. It avoids allocation when passing substrings or literals to functions.

Explanation

std::initializer_list<int> allows vector<int> v = {1,2,3}. A constructor taking initializer_list is preferred when braced initialization is used.

Explanation

decltype(expr) gives the type of the expression. Used in trailing return types: auto add(T a, U b) -> decltype(a + b).

Explanation

Read right-to-left: int* const p — p is a const pointer to int. const int* p — p is a pointer to const int. Both: const int* const p.

Explanation

template<class T, class = void> struct has_size : false_type {}; template<class T> struct has_size<T, void_t<decltype(T::size)>> : true_type {} detects if T has ::size.

Explanation

std::span<T> (C++20) is like std::string_view but for any contiguous range. Passing span<int> accepts int[], vector<int>, and array<int,N>.

Explanation

std::views::filter(isEven) | std::views::transform(square) creates a lazy view. Range algorithms use range objects directly without begin()/end() pairs.

Explanation

class Widget { struct Impl; unique_ptr<Impl> pImpl; }; moves implementation to a .cpp file. Changes to Impl don't recompile Widget's clients.

Explanation

template<typename... Ts> auto sum(Ts... args) { return (args + ...); } uses a right fold. (... + args) is a left fold. Eliminates recursive template specializations.

Explanation

if constexpr (is_integral_v<T>) { ... } else { ... } — the else branch is not instantiated for integral T. Simpler than SFINAE for type-based branching.

Explanation

C++20 designated initializers (struct Config cfg{.timeout = 30, .retries = 3}) improve readability and allow leaving other members zero-initialized.

Explanation

auto operator<=>(const Point& o) const = default; auto-generates ==, !=, <, >, <=, >= using member-by-member comparison.

Explanation

std::expected<int, std::error_code> open(path) returns either a valid int or an error_code. Allows functional error handling without exceptions.

Explanation

CRTP enables mixins: template<class T> struct Printable { void print() { static_cast<T*>(this)->toString(); } }; Adding functionality without virtual dispatch.

Explanation

template<Numeric T> T add(T a, T b) produces "T does not satisfy Numeric" errors. SFINAE equivalent produces a multi-line template instantiation failure trail.

Explanation

coroutine_handle<Promise> points to the coroutine frame. .resume() continues execution; .done() checks completion; .destroy() frees the frame.

Explanation

co_yield x calls promise.yield_value(x), suspending the coroutine. Callers retrieve the value from the promise or via an awaitable returned by the coroutine.

Explanation

std::jthread (C++20) automatically calls join() in its destructor, preventing the "thread destructor calls std::terminate" bug. It also supports stop_source/stop_token for cancellation.

Explanation

The three exception safety guarantees: Basic (no resource leaks), Strong (commit-or-rollback), Nothrow (noexcept). RAII provides basic safety automatically.

Explanation

TMP exploits template instantiation for compile-time computation (e.g., computing Fibonacci at compile time). C++17 constexpr and C++20 concepts reduce the need for TMP.

Explanation

Concepts (requires Integral<T>) provide readable constraints on template parameters. They produce clear error messages and replace intricate enable_if/SFINAE patterns.

Explanation

C++20 coroutines (co_await, co_yield, co_return) are stackless, suspending at specific points. They have minimal overhead vs OS threads and enable async I/O patterns.

Explanation

memory_order controls how atomic operations synchronize with other threads. seq_cst is safest but costliest. relaxed provides no synchronization. acquire-release establishes happens-before pairs.

Explanation

std::any, std::function, and std::variant use type erasure. std::function<void()> holds any callable without the caller knowing the concrete type.

Explanation

template<class T> class Base { }; class Derived : public Base<Derived> { }; enables the base to call derived methods without virtual dispatch overhead.

Explanation

ODR violations (multiple different definitions of the same entity) cause undefined behavior. Inline, constexpr, and template definitions in headers are ODR-exempt if identical.

Explanation

new (buffer) MyClass(args) constructs a MyClass in the already-allocated buffer. Used in memory pools and custom allocators. Requires explicit destructor call.

Explanation

C unions don't track the active member and don't call constructors for non-trivial types. std::variant is type-safe, runs constructors/destructors, and enables std::visit.

Explanation

C++20 modules (export module mylib;) compile once and provide a binary module interface. They improve build times, prevent macro pollution, and enforce encapsulation.

Explanation

std::vector<int, PoolAlloc<int>> uses a custom allocator. allocator_traits<A> provides defaults for optional allocator members. Used in embedded, game, and HPC code.

Explanation

consteval functions are "immediate functions" — every call must produce a constant. If the argument is not a constant expression, compilation fails. constexpr may run at either time.

Explanation

ASan instruments the binary with shadow memory to track valid memory regions. It catches bugs at runtime with precise diagnostics, invaluable during development.

Explanation

UBSan instruments code to detect UB at runtime. Compiling with -fsanitize=undefined catches issues that compilers may silently miscompile in production.

Explanation

If a compiler knows int* and float* can't alias, it reorders loads/stores freely. Violating strict aliasing (common in low-level code) is undefined behavior.

Explanation

Defining operator== as a friend inside the class hides it from normal lookup. It's only found via ADL (Argument-Dependent Lookup), preventing ambiguity with generic operators.

Explanation

std::pmr::vector<int> uses a pluggable allocator passed at construction. std::pmr::monotonic_buffer_resource enables arena allocation without changing container types.

Explanation

Specializing tuple_size<MyType>, tuple_element<N, MyType>, and providing get<N>(MyType&) enables auto [a, b] = myValue for custom types.

Explanation

The Itanium ABI (despite the name, used on x86-64 Linux/macOS) ensures binary compatibility between compilers. MSVC uses its own ABI, which is why Windows mixing requires careful C-style extern "C" interfaces.

Explanation

The as-if rule allows loop unrolling, function inlining, dead code elimination, and instruction reordering as long as the final observable behavior matches the abstract machine.