BudiBaduQuiziBadu

C++ References Quiz

C++
0 Passed
0% acceptance

Explore C++ references including binding rules, differences from pointers, const references, returning references, and reference lifetime management for safe and efficient code.

40 Questions
~80 minutes
1

Question 1

When declaring a reference variable that must be initialized to refer to an existing integer variable, what syntax correctly establishes the reference relationship and prevents reassignment?

cpp
#include <iostream>

int main() {
    int original = 42;
    int& ref = original;  // Reference declaration with &
    
    ref = 100;  // Modifies original through reference
    
    std::cout << "Original: " << original << std::endl;
    std::cout << "Reference: " << ref << std::endl;
    
    // ref = anotherVariable;  // ERROR: cannot rebind reference
    
    return 0;
}
A
int& ref = original establishes a reference that must be initialized and cannot be reassigned, with & indicating reference type and all operations affecting the original variable
B
int ref& is the correct syntax for reference declaration
C
&int ref declares a reference by placing the ampersand before the type
D
References can be declared without initialization and reassigned like pointers
2

Question 2

What is the most significant behavioral difference between references and pointers when used as function parameters for modifying caller variables?

A
References cannot be null and must always refer to valid objects, eliminating null checks while pointers require explicit validation before dereferencing to prevent crashes
B
References are less efficient than pointers for parameter passing
C
Pointers provide better type safety than references
D
References and pointers have identical behavior in function parameters
3

Question 3

When implementing a function that reads data without modifying it, what reference qualifier provides the most appropriate access control while enabling efficient parameter passing?

cpp
#include <iostream>
#include <string>

void printLength(const std::string& text) {
    // Can read but not modify text
    std::cout << "Length: " << text.length() << std::endl;
    // text = "new value";  // ERROR: cannot modify const reference
}

int main() {
    std::string message = "Hello, World!";
    printLength(message);
    
    return 0;
}
A
const std::string& prevents modification while allowing efficient pass-by-reference, avoiding copying large objects while maintaining const correctness
B
std::string& allows modification but is less efficient for large objects
C
const should never be used with reference parameters
D
References automatically prevent all modifications
4

Question 4

What happens when a reference is created to a temporary object, and why does this create potential lifetime issues?

A
Binding a reference to a temporary extends the temporary's lifetime to match the reference, but returning such references from functions creates dangling references when the temporary is destroyed
B
References to temporaries are always safe and have no lifetime issues
C
Temporaries cannot be bound to references
D
Reference lifetime is independent of the referenced object's lifetime
5

Question 5

When returning a reference from a function that needs to provide modifiable access to an internal data member, what lifetime consideration is most critical for preventing undefined behavior?

cpp
#include <iostream>
#include <string>

class BadExample {
private:
    std::string data;
public:
    // DANGEROUS: returns reference to local variable
    std::string& getData() {
        std::string local = "temporary";
        return local;  // Returns reference to destroyed object
    }
};

class GoodExample {
private:
    std::string data = "persistent";
public:
    // SAFE: returns reference to member variable
    std::string& getData() {
        return data;
    }
};

int main() {
    GoodExample obj;
    std::string& ref = obj.getData();
    ref = "modified";
    
    std::cout << obj.getData() << std::endl;
    
    return 0;
}
A
The referenced object must outlive the reference, requiring return of references to member variables or static objects rather than local variables that are destroyed when the function returns
B
Function return values automatically extend object lifetimes
C
References can safely extend any object's lifetime
D
Lifetime rules don't apply to function return values
6

Question 6

What is the key advantage of using references over pointers for operator overloading, particularly for the assignment operator?

A
References prevent null assignments and self-assignment issues, providing cleaner syntax while ensuring the right operand always refers to a valid object
B
Pointers provide better performance for operator overloading
C
References cannot be used in operator overloading
D
Pointers are required for all operator overloading
7

Question 7

When implementing a function that needs to modify multiple variables passed as parameters, what combination of references and pointers provides the most appropriate interface design?

cpp
#include <iostream>

void modifyValues(int& ref, int* ptr) {
    ref = 100;  // Always safe, cannot be null
    if(ptr != nullptr) {
        *ptr = 200;  // Requires null check
    }
}

int main() {
    int a = 1, b = 2;
    modifyValues(a, &b);
    
    std::cout << "a: " << a << ", b: " << b << std::endl;
    
    return 0;
}
A
Use references for required parameters and pointers for optional ones, combining guaranteed validity with null-checking flexibility in the same function interface
B
Always use pointers for all parameters to maintain consistency
C
Always use references for all parameters since they're safer
D
Mixing references and pointers in the same function is not allowed
8

Question 8

What is the fundamental reason references cannot be reassigned after initialization, and how does this affect their use in data structures?

A
References are implemented as constant pointers internally, making reassignment impossible and requiring careful initialization planning in containers and algorithms
B
References can be reassigned like pointers with different syntax
C
Reassignment restriction only applies to const references
D
References are automatically reassigned when the referenced object changes
9

Question 9

When designing a class that holds references as member variables, what initialization requirement must be satisfied in all constructors?

cpp
#include <iostream>

class ReferenceHolder {
private:
    int& ref;  // Must be initialized
public:
    // Constructor must initialize reference
    ReferenceHolder(int& value) : ref(value) {}
    
    void print() {
        std::cout << "Value: " << ref << std::endl;
    }
};

int main() {
    int data = 42;
    ReferenceHolder holder(data);
    holder.print();
    
    data = 100;
    holder.print();  // Shows modified value
    
    return 0;
}
A
Reference members must be initialized in the constructor's member initializer list, as they cannot be default-initialized and require a valid referent throughout the object's lifetime
B
Reference members can be initialized in the constructor body
C
Reference members are automatically initialized to null
D
Classes cannot have reference members
10

Question 10

What is the most significant performance benefit of using const references for large object parameters compared to passing by value?

A
Const references eliminate expensive copy construction and destruction overhead, providing direct access to the original object while preventing accidental modifications
B
References are always slower than passing by value
C
Performance difference is negligible for all object sizes
D
Passing by value is more efficient for large objects
11

Question 11

When implementing a swap function that needs to exchange the contents of two objects efficiently, what reference-based approach provides the most generic and safe implementation?

cpp
#include <iostream>
#include <algorithm>  // For std::swap

class CustomType {
public:
    int value;
    CustomType(int v) : value(v) {}
};

// Generic swap using references
void swap(CustomType& a, CustomType& b) {
    CustomType temp = a;
    a = b;
    b = temp;
}

int main() {
    CustomType x(10), y(20);
    
    std::cout << "Before: x=" << x.value << ", y=" << y.value << std::endl;
    
    swap(x, y);
    
    std::cout << "After: x=" << x.value << ", y=" << y.value << std::endl;
    
    return 0;
}
A
Non-const references enable efficient in-place swapping with guaranteed validity, avoiding pointer null checks while allowing direct object manipulation
B
Pointers are required for generic swap implementations
C
Swap functions cannot use references safely
D
References make swap operations less efficient
12

Question 12

What happens when a reference parameter is used in a recursive function, and how does this affect stack usage compared to pointer parameters?

A
Reference parameters have identical stack usage to pointer parameters, as both typically pass a single address value, but references provide cleaner syntax without null possibility
B
References use more stack space than pointers in recursive functions
C
Recursive functions cannot use reference parameters
D
References automatically optimize recursive stack usage
13

Question 13

When designing an API that needs to return a reference to an internal cache that may not always be available, what design pattern provides the most appropriate solution?

A
Return by value for cache misses and reference for hits, or use optional references with std::optional, ensuring callers handle both cases appropriately
B
Always return references even when cache is empty
C
Use pointers to indicate cache miss with nullptr
D
Cache APIs should never return references
14

Question 14

What is the key difference in how references and pointers behave during object construction and destruction in member initialization?

cpp
#include <iostream>

class Owner {
private:
    int& ref;    // Must be initialized
    int* ptr;    // Can be default initialized
public:
    Owner(int& r, int* p = nullptr) : ref(r), ptr(p) {}
    
    void show() {
        std::cout << "ref: " << ref;
        if(ptr) std::cout << ", ptr: " << *ptr;
        std::cout << std::endl;
    }
};

int main() {
    int value = 42;
    Owner owner(value);
    owner.show();
    
    return 0;
}
A
Reference members require initialization in the constructor initializer list while pointer members can be default-initialized, affecting class design and constructor requirements
B
References and pointers behave identically in member initialization
C
Pointers require more complex initialization than references
D
Member references cannot be used in classes
15

Question 15

When implementing a function that needs to modify a variable through a parameter while also accepting rvalue arguments, what reference qualifier provides the most flexible interface?

cpp
#include <iostream>

void increment(int& value) {
    value++;
}

// Overload for rvalues (uncommon but possible)
void increment(int&& value) {
    value++;
}

int main() {
    int x = 5;
    increment(x);  // Uses int&
    std::cout << "x after increment: " << x << std::endl;
    
    increment(10);  // Uses int&& (modifies temporary)
    
    return 0;
}
A
Universal references with auto&& or function overloading with T&& provide flexibility to accept both lvalues and rvalues, enabling modification of temporaries when needed
B
Only lvalue references can modify variables
C
Rvalue references cannot be used for modification
D
References cannot accept both lvalues and rvalues
16

Question 16

What is the most significant safety advantage of using references over pointers in container element access methods like std::vector::operator[]?

A
References guarantee valid access to existing elements while pointers could be null or invalid, eliminating null checks in element access operations
B
Pointers provide better bounds checking than references
C
References cannot be used for container element access
D
Container access methods always use pointers internally
17

Question 17

When implementing a comparator function for sorting algorithms, what reference usage pattern provides the most efficient and safe parameter passing?

A
Const references enable efficient comparison of large objects without copying while preventing accidental modification during comparison operations
B
Comparators must always copy their arguments for safety
C
Pointers are more efficient than references for comparators
D
References cannot be used safely in comparator functions
18

Question 18

What is the fundamental limitation of using references as return types from functions that create new objects dynamically?

A
Functions cannot return references to local variables or temporaries, requiring return by value or smart pointers for dynamically created objects to prevent dangling references
B
References can safely be returned from any function
C
Dynamic object creation always requires pointer returns
D
References extend the lifetime of dynamically created objects
19

Question 19

When designing a class hierarchy where derived classes need to override methods that return references to internal state, what reference qualifier ensures proper polymorphic behavior?

cpp
#include <iostream>

class Base {
protected:
    int value = 42;
public:
    virtual int& getValue() { return value; }
};

class Derived : public Base {
private:
    int derivedValue = 100;
public:
    int& getValue() override { return derivedValue; }
};

int main() {
    Derived d;
    Base& baseRef = d;
    
    int& valRef = baseRef.getValue();  // Calls Derived::getValue
    valRef = 200;
    
    std::cout << "Derived value: " << d.getValue() << std::endl;
    
    return 0;
}
A
Virtual functions returning references enable polymorphic access to derived class state, allowing base class references to access correct derived member variables
B
References cannot be used in virtual functions
C
Polymorphism requires pointer return types
D
Virtual functions always return by value
20

Question 20

What is the most critical consideration when using references in multi-threaded programs where shared data is accessed concurrently?

A
References provide no inherent thread safety and require external synchronization just like pointers, as they don't prevent race conditions or data races
B
References automatically synchronize access in multi-threaded code
C
Multi-threaded programs cannot use references safely
D
References prevent all race conditions automatically
21

Question 21

When implementing a range-based for loop that needs to modify elements, what reference usage provides the most efficient and safe iteration pattern?

cpp
#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    // Reference iteration allows modification
    for(int& num : numbers) {
        num *= 2;
    }
    
    // Display modified values
    for(int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    return 0;
}
A
Non-const references in range-based for loops enable efficient in-place modification of container elements without copying or pointer management overhead
B
Range-based for loops cannot modify elements
C
Pointers are required for modifying elements in range-based loops
D
References make range-based loops less efficient
22

Question 22

What is the key advantage of using const references in lambda capture lists compared to copying large objects?

A
Const reference captures avoid expensive copy operations while preventing modification of captured objects, ensuring lambda safety and performance
B
Lambdas cannot capture objects by reference
C
Copying is always more efficient than reference capture
D
Reference captures automatically make lambdas unsafe
23

Question 23

When designing a function template that needs to work with both lvalue and rvalue arguments, what reference template parameter provides universal argument handling?

cpp
#include <iostream>

// Universal reference template
function template<typename T>
void process(T&& arg) {
    std::cout << "Processing: " << arg << std::endl;
}

int main() {
    int x = 42;
    process(x);      // lvalue reference
    process(100);    // rvalue reference
    process(x + 1);  // rvalue reference
    
    return 0;
}
A
T&& universal references with reference collapsing rules enable perfect forwarding, accepting any argument type while preserving value category information
B
Templates cannot handle both lvalues and rvalues
C
const T& is sufficient for all template parameters
D
Universal references make templates less flexible
24

Question 24

What is the most significant limitation of using references in standard library containers compared to pointers?

A
References cannot be stored in containers due to their immutability and initialization requirements, requiring pointers or smart pointers for dynamic collections
B
Containers can store references more efficiently than pointers
C
References are the preferred type for all container storage
D
Containers automatically convert references to pointers
25

Question 25

When implementing operator[] for a custom container class, what return type provides the most appropriate balance of safety and usability?

A
Non-const reference for modifiable access with bounds checking provides direct element access while allowing modification and preventing out-of-bounds errors
B
Pointers provide better safety than references for operator[]
C
operator[] should always return by value
D
References cannot be used safely in operator[]
26

Question 26

What is the fundamental reason that references cannot be used in union members while pointers can?

A
References require initialization and cannot be default-constructed, conflicting with union member requirements for trivial construction and destruction
B
Unions can contain references without restrictions
C
Pointers cannot be used in unions
D
References are automatically converted to pointers in unions
27

Question 27

When designing a callback system using std::function, what reference-related consideration affects how member function pointers are stored and invoked?

cpp
#include <iostream>
#include <functional>

class Button {
public:
    void click() {
        std::cout << "Button clicked!" << std::endl;
    }
};

int main() {
    Button btn;
    
    // Store member function pointer
    std::function<void()> callback = std::bind(&Button::click, &btn);
    
    callback();  // Calls btn.click()
    
    return 0;
}
A
Member function pointers require object instance binding, typically using pointers or references to the object instance for proper this pointer resolution
B
std::function cannot store member function pointers
C
Member functions don't require object instance binding
D
References cannot be used with member function pointers
28

Question 28

What is the most significant performance implication of using references versus pointers in hot code paths with small data types?

A
References and pointers have identical performance for small types, as both typically involve single indirection with similar optimization opportunities for modern compilers
B
References are always slower than pointers due to additional safety checks
C
Pointers are always slower than references for small data types
D
Performance difference is significant for all data sizes
29

Question 29

When implementing a factory function that returns objects by reference, what lifetime management strategy prevents use-after-free errors?

A
Return references only to static or member variables with guaranteed lifetime, or use ownership transfer patterns that document lifetime responsibilities clearly
B
Factory functions can safely return references to any created object
C
References automatically manage object lifetime in factory functions
D
Factory functions should never return references
30

Question 30

What is the key semantic difference between lvalue references and rvalue references in function overloading resolution?

A
Lvalue references bind to named objects while rvalue references bind to temporaries, enabling perfect forwarding and move semantics in overloaded functions
B
Rvalue references are more restrictive than lvalue references
C
Function overloading cannot distinguish between lvalue and rvalue references
D
Lvalue and rvalue references have identical binding behavior
31

Question 31

When designing exception-safe code that uses references to manage resources, what reference pattern provides the most robust error handling?

A
RAII with reference members ensures proper cleanup during exceptions, as destructors are called automatically even when exceptions unwind the stack
B
References automatically handle exceptions without RAII
C
Exception handling requires pointers instead of references
D
References make exception handling more difficult
32

Question 32

What is the most significant limitation when using references as template parameters compared to using pointers?

cpp
#include <iostream>

// Template with pointer parameter
template<typename T>
void processPtr(T* ptr) {
    if(ptr) std::cout << "Value: " << *ptr << std::endl;
}

// Template with reference parameter
template<typename T>
void processRef(T& ref) {
    std::cout << "Value: " << ref << std::endl;
}

int main() {
    int* ptr = nullptr;
    int value = 42;
    
    processPtr(ptr);     // Safe with null
    processRef(value);   // Cannot pass null
    
    return 0;
}
A
Reference template parameters cannot be null, requiring different error handling strategies than pointer parameters which can represent absence of value
B
Templates cannot use reference parameters
C
Pointer template parameters are less flexible than references
D
References make templates more restrictive than pointers
33

Question 33

When implementing a copy constructor that takes its parameter by reference, what const qualification is essential and why?

cpp
#include <iostream>
#include <string>

class MyClass {
private:
    std::string data;
public:
    // Copy constructor must take const reference
    MyClass(const MyClass& other) : data(other.data) {
        std::cout << "Copy constructor called" << std::endl;
    }
    
    MyClass(std::string s) : data(std::move(s)) {}
};

int main() {
    MyClass obj1("Hello");
    MyClass obj2 = obj1;  // Calls copy constructor
    
    return 0;
}
A
const qualification prevents modification of the source object during copying, enabling pass-by-reference efficiency while maintaining const correctness and preventing accidental changes
B
Copy constructors can modify their parameters
C
const is optional in copy constructor parameters
D
Copy constructors should take parameters by value
34

Question 34

What is the most critical consideration when returning references from overloaded operators, particularly the assignment operator?

A
Return by reference enables operator chaining while avoiding unnecessary copies, but requires ensuring the returned reference refers to a valid object with appropriate lifetime
B
Overloaded operators should always return by value
C
References cannot be used in operator return types
D
Operator chaining requires pointer returns
35

Question 35

When designing a generic algorithm that needs to work with both modifiable and const containers, what reference template pattern provides the most flexible interface?

A
Const and non-const reference overloads enable algorithms to work with both const and non-const containers, providing appropriate access levels for each use case
B
Generic algorithms cannot work with both const and non-const containers
C
All algorithms should use const references only
D
Non-const references are sufficient for all generic algorithms
36

Question 36

What is the fundamental reason that function parameters declared as references cannot have default arguments that are temporaries?

A
Reference parameters must be initialized to valid objects, and temporary default arguments would create dangling references when the function call completes
B
References can have temporary default arguments safely
C
Function parameters cannot have default arguments
D
Default arguments automatically extend temporary lifetimes
37

Question 37

When implementing a class that holds references to external objects, what destructor consideration is most important for preventing undefined behavior?

A
Reference member destructors don't delete referenced objects, requiring clear ownership documentation to prevent use-after-free when referenced objects are destroyed elsewhere
B
Reference members automatically delete their referenced objects
C
Classes cannot safely hold reference members
D
Destructors should delete reference members
38

Question 38

What is the most significant advantage of using const references in range-based for loops when iterating over large containers?

cpp
#include <iostream>
#include <vector>
#include <string>

int main() {
    std::vector<std::string> words = {"hello", "world", "this", "is", "a", "test"};
    
    // Const reference avoids copying strings
    for(const std::string& word : words) {
        std::cout << word << " ";
    }
    std::cout << std::endl;
    
    return 0;
}
A
Const references prevent expensive copy construction of large objects during iteration, providing efficient read-only access to container elements
B
Range-based for loops always copy elements regardless of reference usage
C
References make range-based loops less efficient
D
Const references are not allowed in range-based for loops
39

Question 39

When designing a template function that forwards arguments to another function, what reference collapsing rule enables perfect forwarding?

A
T&& universal reference parameters with std::forward preserve the original value category of arguments, enabling efficient forwarding without unnecessary copies
B
Perfect forwarding cannot be achieved with references
C
std::forward requires pointer parameters
D
Reference collapsing makes forwarding less efficient
40

Question 40

What is the most critical safety consideration when using references in interrupt service routines or signal handlers?

A
References may not be safely used in asynchronous contexts due to potential for accessing invalid objects, requiring careful lifetime management and possibly using pointers instead
B
References are safer than pointers in interrupt handlers
C
Interrupt handlers cannot use references at all
D
References automatically handle asynchronous access safely

Other Quiz Categories

JavaScript
47 quizzes
Basics
Variables & Data Types
Operators & Expressions
Rust
30 quizzes
Cargo and Project Setup
Variables and Mutability
Data Types
Python
29 quizzes
Introduction & Core Fundamentals
Data Types Overview
Type Casting
Golang
29 quizzes
Basics & Syntax
Data Types & Zero Values
Operators & Expressions
Java
22 quizzes
Java Basics & JVM Fundamentals
Variables, Data Types & Type Casting
Operators & Expressions
Matlab
21 quizzes
Basics & Environment
Variables and Data Type
Arrays and Matric
TypeScript
19 quizzes
Introduction and Overview
Installation and Configuration
Basic Types and Type Annotations
SQL Database
15 quizzes
Foundations and Basics
Basic Query Selection
Filter, Sort, and Alias Essentials
PHP
15 quizzes
Syntax Building Blocks
Variable Naming
Data Types Overview
Linked List
11 quizzes
Introduction
Node Structure and Pointer Fundamentals
Singly Linked List

QUIZZES IN C++

1

Basics

10

40 in-depth questions covering C++ fundamentals, program structure, input/output operations, comments, compilation process, and exit codes — with 10 code examples to solidify understanding.

2

Variables & Data Types

40

40 in-depth questions covering C++ fundamental types, type modifiers, auto inference, type ranges, literals, and initialization patterns — with 10 code examples to solidify understanding.

3

Operators & Expression

40

40 in-depth questions covering C++ arithmetic, comparison, logical operators, compound assignments, and precedence rules — with 10 code examples to solidify understanding.

4

Control Flow

40

40 in-depth questions covering C++ control flow statements including conditional execution, loops, and flow control mechanisms — with 10 code examples to solidify understanding.

5

Function

40

40 in-depth questions covering C++ function fundamentals including declaration, parameters, overloading, passing mechanisms, and inline functions — with 10 code examples to solidify understanding.

6

Arrays & Strings

40

40 comprehensive questions on C++ arrays and strings, covering fixed-size arrays, C-style strings, std::string fundamentals, string operations, and array iteration patterns — with 20 code examples to master memory management and string handling.

7

Pointer

40

Master the fundamentals of C++ pointers including declaration, dereferencing, null pointers, pointer arithmetic, and advanced concepts like pointers to arrays and pointers to pointers.

8

References

40

Explore C++ references including binding rules, differences from pointers, const references, returning references, and reference lifetime management for safe and efficient code.

9

Dynamic Memory

35

Comprehensive C++ quiz exploring dynamic memory management including new/delete operators, array allocation, memory leaks, dangling pointers, and the motivation for smart pointers in modern C++.

10

Structs & Basic Classes

40

Comprehensive C++ quiz exploring fundamental object-oriented programming concepts including struct vs class differences, member variables, methods, access specifiers, and object initialization patterns.

11

Constructors & Destructors

40

40 in-depth questions covering C++ constructors and destructors, including default/parameterized constructors, initializer lists, copy/move constructors, and RAII concepts — with 16 code examples to master object lifecycle management.

12

Operator Overloading

35

35 in-depth questions covering C++ operator overloading, including arithmetic operators, comparison operators, stream operators, assignment rules, and best practices — with 16 code examples to master operator design and pitfalls.

13

The Standard Template Library (STL)

40

40 in-depth questions covering C++ STL fundamentals including std::vector, std::map, std::unordered_map, std::pair, std::tuple, std::set, and best practices for containers — with 16 code examples to master STL usage and pitfalls.

14

Iterator

40

40 in-depth questions covering C++ iterator fundamentals including iterator categories, STL container usage, begin/end patterns, reverse iterators, and iterator invalidation rules — with 16 code examples to master iterator-based programming.

15

OOP: Inheritance

40

40 in-depth questions covering C++ inheritance fundamentals including base and derived classes, protected members, method overriding, final and override keywords, and inheritance best practices — with 16 code examples to master object-oriented inheritance patterns.

16

OOP: Polymorphism

40

40 in-depth questions covering C++ polymorphism fundamentals including virtual functions, pure virtual functions, abstract classes, virtual destructors, and dynamic dispatch — with 16 code examples to master runtime polymorphism patterns.

17

Templates & Generics

40

40 in-depth questions covering C++ template fundamentals including function templates, class templates, template type deduction, non-type template parameters, and generic programming style — with 16 code examples to master compile-time polymorphism patterns.

18

Exception Handling

40

40 in-depth questions covering C++ exception handling mechanisms, try/catch/throw blocks, exception types, stack unwinding, custom exceptions, and noexcept specification — with 16 code examples to solidify understanding.

19

File I/O

40

40 in-depth questions covering C++ file input/output operations, stream classes, text and binary file handling, error checking, and RAII patterns — with 16 code examples to solidify understanding.

20

Smart Pointer

40

40 in-depth questions covering C++ smart pointer types, ownership semantics, memory management, and cyclic reference avoidance — with 16 code examples to solidify understanding.

21

Move Semantics & Perfect Forwarding

40

40 in-depth questions covering C++ move semantics, rvalue references, move constructors, std::move, perfect forwarding with std::forward, and performance considerations — with 16 code examples to solidify understanding.

22

Lambda Expressions

40

40 in-depth questions covering C++ lambda expressions, capture lists, mutable lambdas, returning lambdas, storing lambdas in std::function, and lambda recursion techniques — with 16 code examples to solidify understanding.

23

Concurrency

40

40 in-depth questions covering C++ concurrency with std::thread, thread synchronization, mutex types, condition variables, and race condition avoidance — with 16 code examples to solidify understanding.

24

Async & Futures

40

40 in-depth questions covering C++ async programming with std::async, std::future, std::promise, task-based concurrency, and custom thread pool patterns — with 16 code examples to solidify understanding.

25

Memory Management Deep Dive

40

40 in-depth questions covering advanced C++ memory management with custom allocators, memory pools, RAII patterns, and cache-friendly programming — with 16 code examples to solidify understanding.

26

Advanced Templates

40

40 in-depth questions covering advanced C++ template metaprogramming with SFINAE, variadic templates, constexpr, and compile-time computation — with 16 code examples to solidify understanding.