Real-World C++ InterviewsLesson 147
Selected · FreeQuestion 147: How C++ differs from C
InternFresher
Language fundamentals
Loading a new page.
Learning library
C++ library
Choose a lesson to read explanations, explore examples, and practice questions.
Filter by C++ version or collection
Lesson list
541 results
Real-World C++ InterviewsLesson 1
Selected · FreeQuestion 001: Type deduction with auto
FresherJunior
Language fundamentalsTemplates and compile-time programming
Real-World C++ InterviewsLesson 6
Selected · FreeQuestion 006: Reading expression types with decltype
Junior
Language fundamentalsTemplates and compile-time programming
Real-World C++ InterviewsLesson 170
Selected · FreeQuestion 170: Resource cleanup when exceptions occur
JuniorMiddle
Memory management and lifetimeDebugging and correctness
Real-World C++ InterviewsLesson 58
Selected · FreeQuestion 058: What std::move actually does
FresherJunior
Language fundamentalsMemory management and lifetime
Real-World C++ InterviewsLesson 263
Selected · FreeQuestion 263: Removing vector elements and reusing capacity
FresherJunior
Memory management and lifetimeStandard library and containers
Real-World C++ InterviewsLesson 258
Selected · FreeQuestion 258: When to use endl and flush
JuniorMiddle
Performance and optimizationBuild, I/O, and systems
Real-World C++ InterviewsLesson 176
Selected · FreeQuestion 176: SFINAE and template specialization
JuniorMiddle
Templates and compile-time programming
Real-World C++ InterviewsLesson 219
Selected · FreeQuestion 219: Waiting with a condition-variable predicate
JuniorMiddle
Concurrency and memory modelDebugging and correctness
Real-World C++ InterviewsLesson 254
Selected · FreeQuestion 254: A queue for one producer and consumer
MiddleSenior
Memory management and lifetimeConcurrency and memory modelDebugging and correctness
C++98Lesson 1
C++98 Object / Variable / Memory
C++98Lesson 2
C++98 Prep - Address / Pointer
C++98Lesson 3
C++98 Reference
C++98Lesson 4
C++98 Prep - Array and One-Past-End
C++98Lesson 5
C++98 Struct and Padding
C++11Lesson 1
Day 1 — Toolchain, Compiler Flags, and C++11 Mode
C++11Lesson 2
Day 2 — const, Pointers, and Lvalue References
C++11Lesson 3
Day 3 — Scope, Storage Duration, and Object Lifetime
C++11Lesson 4
Day 4 — nullptr and std::nullptr_t
C++11Lesson 5
Day 5 — auto and Type Deduction
C++11Lesson 6
Day 6 — decltype and Trailing Return Types
C++11Lesson 7
Day 7 — Type Aliases, enum class, and Nested Templates
C++11Lesson 8
Day 8 — Uniform Initialization and Narrowing Conversions
C++11Lesson 9
Day 9 — std::initializer_list and Overload Resolution
C++11Lesson 10
Day 10 — std::array, std::vector, Range-for, and std::begin/end
C++11Lesson 11
Day 11 — Lambdas, Captures, mutable, and Capture Lifetime
C++11Lesson 12
Day 12 — Classes, Constructors, and Member Initializer Lists
C++11Lesson 13
Day 13 — Destructors and RAII
C++11Lesson 14
Day 14 — Copy Constructors
C++11Lesson 15
Day 15 — Copy Assignment and the Rule of Three
C++11Lesson 16
Day 16 — lvalue, rvalue, xvalue, and Value Categories
C++11Lesson 17
Day 17 — Rvalue References
C++11Lesson 18
Day 18 — std::move and Moved-from State
C++11Lesson 19
Day 19 — Move Constructors and Move Assignment
C++11Lesson 20
Day 20 — Rule of Five, Rule of Zero, and noexcept Move
C++11Lesson 21
Day 21 — Defaulted and Deleted Functions
C++11Lesson 22
Day 22 — Delegating Constructors and Non-static Member Initializers
C++11Lesson 23
Day 23 — Converting Constructors and explicit Conversion
C++11Lesson 24
Day 24 — std::unique_ptr and Unique Ownership
C++11Lesson 25
Day 25 — std::shared_ptr, std::weak_ptr, and std::make_shared
C++11Lesson 26
Day 26 — Exception Safety and noexcept
C++11Lesson 27
Day 27 — Inheritance, Virtual Destructors, override, and final
C++11Lesson 28
Day 28 — Ref-qualified Members and Inline Namespaces
C++11Lesson 29
Day 29 — Function Templates and Class Templates
C++11Lesson 30
Day 30 — Template Argument Deduction and Overload Resolution
C++11Lesson 31
Day 31 — Alias Templates and Type Traits
C++11Lesson 32
Day 32 — constexpr and static_assert
C++11Lesson 33
Day 33 — SFINAE and std::enable_if
C++11Lesson 34
Day 34 — Forwarding References and Reference Collapsing
C++11Lesson 35
Day 35 — std::forward and Perfect Forwarding
C++11Lesson 36
Day 36 — Variadic Templates and Parameter Packs
C++11Lesson 37
Day 37 — Function Pointers, Functors, std::function, std::bind, and std::ref
C++11Lesson 38
Day 38 — Literals, Raw Strings, Unicode, Attributes, Alignment, and thread_local
C++11Lesson 39
Day 39 — Sequence Containers, emplace, and Container Ownership
C++11Lesson 40
Day 40 — Iterator Categories and Iterator Invalidation
C++11Lesson 41
Day 41 — STL Algorithms, Numeric Algorithms, and Lambdas
C++11Lesson 42
Day 42 — Ordered and Unordered Containers with Hashing
C++11Lesson 43
Day 43 — Stack, Queue, Priority Queue, and Ring Buffer
C++11Lesson 44
Day 44 — std::pair, std::tuple, std::tie, std::chrono, and std::to_string
C++11Lesson 45
Day 45 — std::thread and Thread Lifetime
C++11Lesson 46
Day 46 — Mutexes, Locks, and Condition Variables
C++11Lesson 47
Day 47 — Futures, Promises, and std::async
C++11Lesson 48
Day 48 — Atomic Operations and Compare-and-Swap
C++11Lesson 49
Day 49 — The C++ Memory Model and Memory Ordering
C++11Lesson 50
Day 50 — Data Races, Deadlocks, and False Sharing
C++11Lesson 51
Day 51 — A Lock-free SPSC Queue
C++11Lesson 52
Day 52 — Cache Locality and Data-oriented Design
C++11Lesson 53
Day 53 — Memory Pools, Custom Allocation, Benchmarking, and Profiling
C++14Lesson 1
Day 1 — Toolchain, Compiler Flags, and C++14 Mode
C++14Lesson 2
Day 2 — Reviewing auto, decltype, and Type Deduction
C++14Lesson 3
Day 3 — Reviewing Value Categories, Move Semantics, and Ownership
C++14Lesson 4
Day 4 — Reviewing Lambdas and Capture in C++11
C++14Lesson 5
Day 5 — Reviewing Templates, Parameter Packs, Type Traits, and constexpr
C++14Lesson 6
Day 6 — Reviewing STL Containers, Iterators, Algorithms, and chrono
C++14Lesson 7
Day 7 — Reviewing thread, mutex, atomic, and the C++ Memory Model
C++14Lesson 8
Day 8 — Binary Literals and Digit Separators
C++14Lesson 9
Day 9 — Generic Lambdas
C++14Lesson 10
Day 10 — Lambda Init-Capture
C++14Lesson 11
Day 11 — Move-Only Lambda Capture and Capture Lifetime
C++14Lesson 12
Day 12 — Function Return Type Deduction with auto
C++14Lesson 13
Day 13 — decltype(auto) and Preserving References
C++14Lesson 14
Day 14 — Relaxed constexpr in C++14
C++14Lesson 15
Day 15 — Variable Templates
C++14Lesson 16
Day 16 — [[deprecated]] and the API Lifecycle
C++14Lesson 17
Day 17 — Standard User-Defined Literals for string, chrono, and complex
C++14Lesson 18
Day 18 — std::make_unique and Ownership Factories
C++14Lesson 19
Day 19 — std::exchange and Move-Based State Transitions
C++14Lesson 20
Day 20 — Migrating from C++11 to C++14 and Compiler Compatibility
C++14Lesson 21
Day 21 — Object Lifetime, RAII, Rule of Five, and Rule of Zero
C++14Lesson 22
Day 22 — API Design with Values, References, Pointers, and Ownership
C++14Lesson 23
Day 23 — Exception Safety and noexcept
C++14Lesson 24
Day 24 — Memory Layout, Alignment, Padding, and Sized Deallocation
C++14Lesson 25
Day 25 — Sequence Containers, emplace, and Contiguous Memory
C++14Lesson 26
Day 26 — Iterator Categories, Invalidation, and Reverse Iterators
C++14Lesson 27
Day 27 — STL Algorithms with Generic Lambdas
C++14Lesson 28
Day 28 — Numeric Algorithms and Basic Statistics
C++14Lesson 29
Day 29 — Ordered Containers and Transparent Comparators
C++14Lesson 30
Day 30 — Heterogeneous Lookup
C++14Lesson 31
Day 31 — Unordered Containers, Hashing, reserve, and Load Factor
C++14Lesson 32
Day 32 — queue, priority_queue, and Ring Buffers
C++14Lesson 33
Day 33 — std::pair, std::tuple, std::tie, and std::get<T>
C++14Lesson 34
Day 34 — Designing Function Templates and Class Templates
C++14Lesson 35
Day 35 — Type-Trait Aliases, SFINAE, and std::enable_if
C++14Lesson 36
Day 36 — Variadic Templates and Parameter Packs
C++14Lesson 37
Day 37 — std::integer_sequence and std::index_sequence
C++14Lesson 38
Day 38 — Compile-Time Tables with constexpr and Variable Templates
C++14Lesson 39
Day 39 — Function Pointers, Functors, Generic Lambdas, and std::function
C++14Lesson 40
Day 40 — CRTP, Static Polymorphism, and Virtual Polymorphism
C++14Lesson 41
Day 41 — std::thread, std::async, future, and promise
C++14Lesson 42
Day 42 — mutex, condition_variable, and std::shared_timed_mutex
C++14Lesson 43
Day 43 — Atomic Operations and Compare-and-Swap
C++14Lesson 44
Day 44 — The C++ Memory Model and Memory Ordering
C++14Lesson 45
Day 45 — Data Races, Deadlocks, and False Sharing
C++14Lesson 46
Day 46 — A Lock-Free SPSC Queue
C++14Lesson 47
Day 47 — Cache Locality and Data-Oriented Design
C++14Lesson 48
Day 48 — Memory Pools, Custom Allocators, and Reducing Allocation
C++14Lesson 49
Day 49 — Benchmarking, Profiling, and Compiler Optimization
C++14Lesson 50
Day 50 — Fixed-Width Integers, Binary Parsing, and Endianness
C++17Lesson 1
Day 1 — Toolchain, Compiler Flags, and C++17 Mode
C++17Lesson 2
Day 2 — Reviewing Object Lifetime, RAII, Move Semantics, and Rule of Zero
C++17Lesson 3
Day 3 — Reviewing auto, decltype, Generic Lambdas, and Type Deduction
C++17Lesson 4
Day 4 — Reviewing Templates, Parameter Packs, Type Traits, and constexpr
C++17Lesson 5
Day 5 — Reviewing STL Containers, Iterators, Algorithms, and Callables
C++17Lesson 6
Day 6 — Reviewing Threads, Atomics, and the C++ Memory Model
C++17Lesson 7
Day 7 — New auto Rules with Braced Initialization
C++17Lesson 8
Day 8 — Structured Bindings
C++17Lesson 9
Day 9 — if and switch with an Initializer
C++17Lesson 10
Day 10 — Nested Namespaces
C++17Lesson 11
Day 11 — Inline Variables and the One Definition Rule
C++17Lesson 12
Day 12 — nodiscard, maybe_unused, fallthrough, and __has_include
C++17Lesson 13
Day 13 — Class Template Argument Deduction
C++17Lesson 14
Day 14 — Deduction Guides
C++17Lesson 15
Day 15 — Non-Type Template Parameters with auto
C++17Lesson 16
Day 16 — Fold Expressions
C++17Lesson 17
Day 17 — void_t, conjunction, disjunction, and Callable Type Traits
C++17Lesson 18
Day 18 — if constexpr
C++17Lesson 19
Day 19 — constexpr Lambdas
C++17Lesson 20
Day 20 — Lambda Capture *this and Object Lifetime
C++17Lesson 21
Day 21 — Guaranteed Copy Elision and prvalue Materialization
C++17Lesson 22
Day 22 — Evaluation Order and noexcept in Function Types
C++17Lesson 23
Day 23 — UTF-8 Character Literals, Enum Initialization, and Aggregate Changes
C++17Lesson 24
Day 24 — Migrating from C++14 to C++17 and Compiler Compatibility
C++17Lesson 25
Day 25 — std::optional and Representing an Absent Value
C++17Lesson 26
Day 26 — std::variant and std::visit
C++17Lesson 27
Day 27 — std::any and Type Erasure
C++17Lesson 28
Day 28 — std::string_view and Non-Owning Lifetime
C++17Lesson 29
Day 29 — std::invoke and std::apply
C++17Lesson 30
Day 30 — std::byte and Object Representation
C++17Lesson 31
Day 31 — std::to_chars and std::from_chars
C++17Lesson 32
Day 32 — std::filesystem
C++17Lesson 33
Day 33 — Chrono Rounding, floor, ceil, and Time-Point Conversion
C++17Lesson 34
Day 34 — Map/Set Node Handles, extract, and merge
C++17Lesson 35
Day 35 — size, data, empty, as_const, and weak_from_this
C++17Lesson 36
Day 36 — clamp, sample, not_fn, gcd, and lcm
C++17Lesson 37
Day 37 — std::reduce and std::transform_reduce
C++17Lesson 38
Day 38 — Inclusive, Exclusive, and Transform Scans
C++17Lesson 39
Day 39 — Parallel Algorithms and Execution Policies
C++17Lesson 40
Day 40 — std::pmr and Polymorphic Memory Resources
C++17Lesson 41
Day 41 — std::shared_mutex and std::scoped_lock
C++17Lesson 42
Day 42 — Threads, Futures, Promises, and an Asynchronous Pipeline
C++17Lesson 43
Day 43 — Mutexes, Condition Variables, and Producer-Consumer Design
C++17Lesson 44
Day 44 — Atomic Operations, Compare-and-Swap, and Memory Ordering
C++17Lesson 45
Day 45 — Hardware Interference Size, False Sharing, and std::launder
C++17Lesson 46
Day 46 — A Lock-Free SPSC Queue
C++17Lesson 47
Day 47 — Cache Locality and Data-Oriented Design
C++17Lesson 48
Day 48 — PMR Memory Pools and an Allocation-Free Hot Path
C++17Lesson 49
Day 49 — Benchmarking, Profiling, and Compiler Optimization
C++17Lesson 50
Day 50 — Binary Parsing with byte, string_view, and from_chars
C++20Lesson 1
Day 1 — Toolchain, Compiler Flags, and C++20 Mode
C++20Lesson 2
Day 2 — Lifetime, RAII, Ownership, and Non-Owning Views
C++20Lesson 3
Day 3 — Templates, Type Traits, SFINAE, and if constexpr
C++20Lesson 4
Day 4 — Generic Lambdas, Variadic Templates, and Callables
C++20Lesson 5
Day 5 — Iterators, Algorithms, string_view, and PMR
C++20Lesson 6
Day 6 — Threads, Atomics, and the C++ Memory Model
C++20Lesson 7
Day 7 — Requires Expressions and Requirement Kinds
C++20Lesson 8
Day 8 — Defining Custom Concepts
C++20Lesson 9
Day 9 — The Standard Concepts Library
C++20Lesson 10
Day 10 — Constrained Templates and Abbreviated Function Templates
C++20Lesson 11
Day 11 — Concept Subsumption and Overload Resolution
C++20Lesson 12
Day 12 — Explicit Template Parameter Lists for Lambdas
C++20Lesson 13
Day 13 — Lambda Pack Capture and VA_OPT
C++20Lesson 14
Day 14 — Class Types as Non-Type Template Parameters
C++20Lesson 15
Day 15 — consteval, constexpr, and Immediate Functions
C++20Lesson 16
Day 16 — constinit and Static Initialization
C++20Lesson 17
Day 17 — is_constant_evaluated and the constexpr Standard Library
C++20Lesson 18
Day 18 — constexpr Virtual Functions and explicit(bool)
C++20Lesson 19
Day 19 — Three-Way Comparison and Comparison Categories
C++20Lesson 20
Day 20 — Defaulted Comparisons and Comparison Helpers
C++20Lesson 21
Day 21 — lexicographical_compare_three_way
C++20Lesson 22
Day 22 — Designated Initializers and Aggregate Initialization
C++20Lesson 23
Day 23 — Range-for Initializers and Range Lifetime
C++20Lesson 24
Day 24 — likely, unlikely, and Explicit this Capture
C++20Lesson 25
Day 25 — using enum, char8_t, and Safe Integral Comparisons
C++20Lesson 26
Day 26 — Module Interfaces, Implementation Units, and import
C++20Lesson 27
Day 27 — Modules, Header Units, and Header Migration
C++20Lesson 28
Day 28 — span, Static Extent, and Dynamic Extent
C++20Lesson 29
Day 29 — Range, Iterator, and Sentinel Concepts
C++20Lesson 30
Day 30 — Ranges Algorithms
C++20Lesson 31
Day 31 — Views and Lazy Evaluation
C++20Lesson 32
Day 32 — View Pipelines, Borrowed Ranges, and Dangling Views
C++20Lesson 33
Day 33 — starts_with, ends_with, contains, erase_if, and to_array
C++20Lesson 34
Day 34 — format, vformat, and Custom Formatters
C++20Lesson 35
Day 35 — source_location and osyncstream
C++20Lesson 36
Day 36 — bit_cast, Endian, Bit Operations, Math Constants, midpoint, and bind_front
C++20Lesson 37
Day 37 — Chrono Calendars, Time Zones, and Clock Conversion
C++20Lesson 38
Day 38 — jthread, stop_token, and Automatic Joining
C++20Lesson 39
Day 39 — Cooperative Cancellation and stop_callback
C++20Lesson 40
Day 40 — atomic_ref, Atomic Wait/Notify, and Atomic Smart Pointers
C++20Lesson 41
Day 41 — Counting and Binary Semaphores
C++20Lesson 42
Day 42 — Latch and Reusable Barrier
C++20Lesson 43
Day 43 — Designing a Concurrent Data Pipeline
C++20Lesson 44
Day 44 — Coroutine Model: co_await, co_yield, and co_return
C++20Lesson 45
Day 45 — Promise Type, Coroutine Handle, and Coroutine Frame
C++20Lesson 46
Day 46 — Awaitables, Awaiters, and Suspension Lifecycle
C++20Lesson 47
Day 47 — Generators and Lazy Data Streams
C++20Lesson 48
Day 48 — Asynchronous Tasks with Coroutines
C++20Lesson 49
Day 49 — Coroutine Cancellation, Exceptions, Lifetime, and Allocation
C++20Lesson 50
Day 50 — Cache Locality, Data-Oriented Design, and assume_aligned
C++20Lesson 51
Day 51 — PMR, Allocation-Free Hot Paths, Benchmarking, and Profiling
C++20Lesson 52
Day 52 — Binary Parsing with span, byte, bit_cast, and Endian
C++23Lesson 1
Day 1 — Toolchains and C++23 Support
C++23Lesson 2
Day 2 — CMake C++23, Feature-Test Macros, and Compiler Matrices
C++23Lesson 3
Day 3 — Value Categories, Lifetime, Move, and Perfect Forwarding
C++23Lesson 4
Day 4 — Templates, Concepts, CRTP, and Generic Programming
C++23Lesson 5
Day 5 — Ranges, Views, Iterators, and Sentinels
C++23Lesson 6
Day 6 — Coroutines, RAII, Memory Model, and Concurrency
C++23Lesson 7
Day 7 — if consteval and if !consteval
C++23Lesson 8
Day 8 — C++23 constexpr Extensions
C++23Lesson 9
Day 9 — Decay-Copy with auto(x) and auto{x}
C++23Lesson 10
Day 10 — Simpler Implicit Move
C++23Lesson 11
Day 11 — Explicit Object Parameters and Deducing this
C++23Lesson 12
Day 12 — Deducing this with const and Value Categories
C++23Lesson 13
Day 13 — Deducing this with Templates and Concepts
C++23Lesson 14
Day 14 — Deducing this with CRTP, Mixins, and Recursive Lambdas
C++23Lesson 15
Day 15 — Static Lambdas and Static Call Operators
C++23Lesson 16
Day 16 — Multidimensional Subscript Operator
C++23Lesson 17
Day 17 — Range-Based for Lifetime Extension
C++23Lesson 18
Day 18 — Lambda Syntax, Attributes, and Trailing-Return Scope
C++23Lesson 19
Day 19 — Inherited-Constructor CTAD and Alias Init-Statements
C++23Lesson 20
Day 20 — z/uz Literal Suffixes and Extended Floating Types
C++23Lesson 21
Day 21 — [[assume]] and std::unreachable
C++23Lesson 22
Day 22 — #elifdef, #elifndef, and #warning
C++23Lesson 23
Day 23 — Character Sets, Escapes, and char8_t Portability
C++23Lesson 24
Day 24 — Deprecations, Compatibility, and C++20–C++23 Migration
C++23Lesson 25
Day 25 — Monadic Operations on std::optional
C++23Lesson 26
Day 26 — std::expected and std::unexpected
C++23Lesson 27
Day 27 — Monadic Operations and Error Pipelines with std::expected
C++23Lesson 28
Day 28 — std::move_only_function
C++23Lesson 29
Day 29 — std::forward_like
C++23Lesson 30
Day 30 — std::invoke_r, std::bind_back, and Callable Utilities
C++23Lesson 31
Day 31 — Enum and Bit Utilities
C++23Lesson 32
Day 32 — std::out_ptr and std::inout_ptr
C++23Lesson 33
Day 33 — Lifetime Start, Allocation, and constexpr Smart Pointers
C++23Lesson 34
Day 34 — std::stacktrace and std::source_location
C++23Lesson 35
Day 35 — std::print and std::println
C++23Lesson 36
Day 36 — Formatting Ranges, Tuples, and Thread IDs
C++23Lesson 37
Day 37 — std::spanstream and Buffer-Based I/O
C++23Lesson 38
Day 38 — String Containment and resize_and_overwrite
C++23Lesson 39
Day 39 — Constant Iterators and Const-Aware Ranges
C++23Lesson 40
Day 40 — std::ranges::to and std::from_range
C++23Lesson 41
Day 41 — Container Range Operations
C++23Lesson 42
Day 42 — zip, zip_transform, and enumerate Views
C++23Lesson 43
Day 43 — Adjacent, Adjacent-Transform, and Pairwise Views
C++23Lesson 44
Day 44 — Chunk, Slide, Chunk-By, and Stride Views
C++23Lesson 45
Day 45 — Join-With, Repeat, and Cartesian-Product Views
C++23Lesson 46
Day 46 — as_const, as_rvalue, and Custom Range Adaptors
C++23Lesson 47
Day 47 — C++23 Range Search Algorithms
C++23Lesson 48
Day 48 — Fold Algorithms, ranges::iota, and Shift Algorithms
C++23Lesson 49
Day 49 — std::flat_map and std::flat_multimap
C++23Lesson 50
Day 50 — std::mdspan, Extents, and Multidimensional Data
C++23Lesson 51
Day 51 — mdspan Layouts, Mappings, and Accessors
C++23Lesson 52
Day 52 — std::generator and Lazy Coroutine Sequences
C++23Lesson 53
Day 53 — Standard Library Modules std and std.compat
C++23Lesson 54
Day 54 — Binary Feed Parsing with span, byteswap, and expected
Real-World C++ InterviewsLesson 2
Question 002: When can auto deduce undesired types?
JuniorMiddle
Language fundamentalsMemory management and lifetime
Real-World C++ InterviewsLesson 3
Question 003: What are the advantages of using auto?
InternFresher
Language fundamentals
Real-World C++ InterviewsLesson 4
Question 004: What is the type of myCollection after the following declaration?
InternFresher
Language fundamentals
Real-World C++ InterviewsLesson 5
Question 005: What are trailing return types?
FresherJunior
Language fundamentalsTemplates and compile-time programming
Real-World C++ InterviewsLesson 7
Question 007: When to use decltype(auto)?
JuniorMiddle
Memory management and lifetimeTemplates and compile-time programming
Real-World C++ InterviewsLesson 8
Question 008: Which data type do you get when you add two bools?
InternFresher
Language fundamentals
Real-World C++ InterviewsLesson 9
Question 009: What does a static member variable in C++ mean?
InternFresher
Object-oriented design and APIs
Real-World C++ InterviewsLesson 10
Question 010: What does a static member function mean in C++?
InternFresher
Object-oriented design and APIs
Real-World C++ InterviewsLesson 11
Question 011: What is the static initialization order fiasco?
JuniorMiddle
Debugging and correctnessBuild, I/O, and systems
Real-World C++ InterviewsLesson 12
Question 012: How to solve the static initialization order fiasco?
JuniorMiddle
Object-oriented design and APIsBuild, I/O, and systems
Real-World C++ InterviewsLesson 13
Question 013: What is the difference between function overloading and function overriding?
InternFresher
Object-oriented design and APIs
Real-World C++ InterviewsLesson 14
Question 014: What is a virtual function?
FresherJunior
Object-oriented design and APIs
Real-World C++ InterviewsLesson 15
Question 015: What is the override keyword and what are its advantages?
InternFresher
Object-oriented design and APIsDebugging and correctness
Real-World C++ InterviewsLesson 16
Question 016: Explain the concept of covariant return types and show a use-case where it comes in handy!
JuniorMiddle
Object-oriented design and APIs
Real-World C++ InterviewsLesson 17
Question 017: What is virtual inheritance in C++ and when should you use it?
JuniorMiddle
Object-oriented design and APIs
Real-World C++ InterviewsLesson 18
Question 018: Should we always use virtual inheritance? If yes, why? If not, why not?
Middle
Object-oriented design and APIsPerformance and optimization
Real-World C++ InterviewsLesson 19
Question 019: What’s the output of the following sample program? Is that what you’d expect? Why? Why not?
FresherJunior
Object-oriented design and APIsDebugging and correctness
Real-World C++ InterviewsLesson 20
Question 020: Can you access the public and protected members and functions of a base class if you have private inheritance?
FresherJunior
Object-oriented design and APIs
Real-World C++ InterviewsLesson 21
Question 021: What is private inheritance used for?
JuniorMiddle
Object-oriented design and APIs
Real-World C++ InterviewsLesson 22
Question 022: Can you call a virtual function from a constructor or a destructor?
Junior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 23
Question 023: What role does a virtual destructor play?
FresherJunior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 24
Question 024: Can we inherit from a standard container (such as std::vector)? If so what are the implications?
JuniorMiddle
Object-oriented design and APIsStandard library and containers
Real-World C++ InterviewsLesson 25
Question 025: What does a strong type mean and what advantages does it have?
JuniorMiddle
Object-oriented design and APIsDebugging and correctness
Real-World C++ InterviewsLesson 26
Question 026: Explain short-circuit evaluation
InternFresher
Language fundamentals
Real-World C++ InterviewsLesson 27
Question 027: What is a destructor and how can we overload it?
InternFresher
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 28
Question 028: What is the output of the following piece of code and why?
FresherJunior
Language fundamentalsObject-oriented design and APIs
Real-World C++ InterviewsLesson 29
Question 029: How to use the = delete specifier in C++?
FresherJunior
Language fundamentalsObject-oriented design and APIs
Real-World C++ InterviewsLesson 30
Question 030: What are immediately invoked lambda functions?
FresherJunior
Language fundamentals
Real-World C++ InterviewsLesson 31
Question 031: What kind of captures are available for lambda expressions?
FresherJunior
Language fundamentalsMemory management and lifetime
Real-World C++ InterviewsLesson 32
Question 032: What is the output of the following piece of code and why?
FresherJunior
Language fundamentalsObject-oriented design and APIs
Real-World C++ InterviewsLesson 33
Question 033: What are the advantages of using const local variables?
InternFresher
Language fundamentals
Real-World C++ InterviewsLesson 34
Question 034: Is it a good idea to have const members in a class?
JuniorMiddle
Object-oriented design and APIs
Real-World C++ InterviewsLesson 35
Question 035: Does it make sense to return const objects by value?
Junior
Language fundamentalsPerformance and optimization
Real-World C++ InterviewsLesson 36
Question 036: How should you return const pointers from a function?
FresherJunior
Language fundamentals
Real-World C++ InterviewsLesson 37
Question 037: Should functions return const references?
Junior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 38
Question 038: Should you take plain old data types by const reference as a function parameter?
JuniorMiddle
Object-oriented design and APIsPerformance and optimization
Real-World C++ InterviewsLesson 39
Question 039: Should you pass objects by const reference as a function parameter?
Junior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 40
Question 040: Does the signature of a function declaration has to match the signature of the function definition?
FresherJunior
Language fundamentals
Real-World C++ InterviewsLesson 41
Question 041: Explain what consteval and constinit bring to C++?
Junior
Language fundamentalsTemplates and compile-time programming
Real-World C++ InterviewsLesson 42
Question 042: What is aggregate initialization?
FresherJunior
Language fundamentalsObject-oriented design and APIs
Real-World C++ InterviewsLesson 43
Question 043: What are explicit constructors and what are their advantages?
FresherJunior
Object-oriented design and APIsDebugging and correctness
Real-World C++ InterviewsLesson 44
Question 044: What are user-defined literals?
Junior
Language fundamentalsObject-oriented design and APIs
Real-World C++ InterviewsLesson 45
Question 045: Why should we use nullptr instead of NULL or 0?
InternFresher
Language fundamentalsDebugging and correctness
Real-World C++ InterviewsLesson 46
Question 046: What advantages does alias have over typedef?
FresherJunior
Language fundamentalsTemplates and compile-time programming
Real-World C++ InterviewsLesson 47
Question 047: What are the advantages of scoped enums over unscoped enums?
InternFresher
Language fundamentals
Real-World C++ InterviewsLesson 48
Question 048: Should you explicitly delete unused/unsupported special functions or declare them as private?
FresherJunior
Object-oriented design and APIsDebugging and correctness
Real-World C++ InterviewsLesson 49
Question 049: How to use the = delete specifier in C++?
FresherJunior
Language fundamentalsObject-oriented design and APIs
Real-World C++ InterviewsLesson 50
Question 050: What is a trivial class in C++?
JuniorMiddle
Object-oriented design and APIsTemplates and compile-time programming
Real-World C++ InterviewsLesson 51
Question 051: Explain the Resource acquisition is initialization (RAII) idiom
FresherJunior
Memory management and lifetime
Real-World C++ InterviewsLesson 52
Question 052: When should we use unique pointers?
FresherJunior
Memory management and lifetime
Real-World C++ InterviewsLesson 53
Question 053: What are the reasons to use shared pointers?
JuniorMiddle
Memory management and lifetimeConcurrency and memory model
Real-World C++ InterviewsLesson 54
Question 054: When to use a weak pointer?
Junior
Memory management and lifetime
Real-World C++ InterviewsLesson 55
Question 055: What are the advantages of std::make_shared and std::make_unique compared to the new operator?
JuniorMiddle
Memory management and lifetimePerformance and optimization
Real-World C++ InterviewsLesson 56
Question 056: Should you use smart pointers over raw pointers all the time?
Junior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 57
Question 057: When and why should we initialize pointers to nullptr?
InternFresher
Language fundamentalsMemory management and lifetime
Real-World C++ InterviewsLesson 59
Question 059: What does std::forward forward?
Junior
Templates and compile-time programming
Real-World C++ InterviewsLesson 60
Question 060: What is the difference between universal and rvalue references?
JuniorMiddle
Templates and compile-time programming
Real-World C++ InterviewsLesson 61
Question 061: What is reference collapsing?
Junior
Templates and compile-time programming
Real-World C++ InterviewsLesson 62
Question 062: When constexpr functions are evaluated?
FresherJunior
Language fundamentalsTemplates and compile-time programming
Real-World C++ InterviewsLesson 63
Question 063: When should you declare your functions as noexcept?
JuniorMiddle
Performance and optimizationDebugging and correctness
Real-World C++ InterviewsLesson 64
Question 064: What are concepts in C++?
Junior
Templates and compile-time programming
Real-World C++ InterviewsLesson 65
Question 065: What are the available standard attributes in C++?
FresherJunior
Language fundamentals
Real-World C++ InterviewsLesson 66
Question 066: What is 3-way comparison?
Junior
Language fundamentalsObject-oriented design and APIs
Real-World C++ InterviewsLesson 67
Question 067: Explain what consteval and constinit bring to C++?
Junior
Language fundamentalsTemplates and compile-time programming
Real-World C++ InterviewsLesson 68
Question 068: What are modules and what advantages do they bring?
JuniorMiddle
Build, I/O, and systems
Real-World C++ InterviewsLesson 69
Question 069: Explain the rule of three
FresherJunior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 70
Question 070: Explain the rule of five
FresherJunior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 71
Question 071: Explain the rule of zero
FresherJunior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 72
Question 072: What does std::move move?
FresherJunior
Language fundamentalsMemory management and lifetime
Real-World C++ InterviewsLesson 73
Question 073: What is a destructor and how can we overload it?
InternFresher
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 74
Question 074: Should you explicitly delete unused/unsupported special functions or declare them as private?
FresherJunior
Object-oriented design and APIsDebugging and correctness
Real-World C++ InterviewsLesson 75
Question 075: What is a trivial class in C++?
JuniorMiddle
Object-oriented design and APIsTemplates and compile-time programming
Real-World C++ InterviewsLesson 76
Question 076: What advantages does having a default constructor have?
Junior
Object-oriented design and APIs
Real-World C++ InterviewsLesson 77
Question 077: What are the differences between a class and a struct?
InternFresher
Object-oriented design and APIs
Real-World C++ InterviewsLesson 78
Question 078: What is constructor delegation?
FresherJunior
Object-oriented design and APIs
Real-World C++ InterviewsLesson 79
Question 079: Explain the concept of covariant return types and show a use-case where it comes in handy!
JuniorMiddle
Object-oriented design and APIs
Real-World C++ InterviewsLesson 80
Question 080: What is the difference between function overloading and function overriding?
InternFresher
Object-oriented design and APIs
Real-World C++ InterviewsLesson 81
Question 081: What is the override keyword and what are its advantages?
InternFresher
Object-oriented design and APIsDebugging and correctness
Real-World C++ InterviewsLesson 82
Question 082: Explain what is a friend class or a friend function
FresherJunior
Object-oriented design and APIs
Real-World C++ InterviewsLesson 83
Question 083: What are default arguments? How are they evaluated in a C++ function?
Junior
Language fundamentalsObject-oriented design and APIs
Real-World C++ InterviewsLesson 84
Question 084: What is this pointer and can we delete it?
JuniorMiddle
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 85
Question 085: What is virtual inheritance in C++ and when should you use it?
JuniorMiddle
Object-oriented design and APIs
Real-World C++ InterviewsLesson 86
Question 086: Should we always use virtual inheritance? If yes, why? If not, why not?
Middle
Object-oriented design and APIsPerformance and optimization
Real-World C++ InterviewsLesson 87
Question 087: What does a strong type mean and what advantages does it have?
JuniorMiddle
Object-oriented design and APIsDebugging and correctness
Real-World C++ InterviewsLesson 88
Question 088: What are user-defined literals?
Junior
Language fundamentalsObject-oriented design and APIs
Real-World C++ InterviewsLesson 89
Question 089: Why shouldn’t we use boolean arguments?
JuniorMiddle
Object-oriented design and APIs
Real-World C++ InterviewsLesson 90
Question 090: Distinguish between shallow copy and deep copy
FresherJunior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 91
Question 091: Are class functions taken into consideration as part of the object size?
FresherJunior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 92
Question 092: What does dynamic dispatch mean?
FresherJunior
Object-oriented design and APIs
Real-World C++ InterviewsLesson 93
Question 093: What are vtable and vpointer?
Junior
Object-oriented design and APIsBuild, I/O, and systems
Real-World C++ InterviewsLesson 94
Question 094: Should base class destructors be virtual?
Junior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 95
Question 095: What is an abstract class in C++?
InternFresher
Object-oriented design and APIs
Real-World C++ InterviewsLesson 96
Question 096: Is it possible to have polymorphic behaviour without the cost of virtual functions?
Middle
Object-oriented design and APIsTemplates and compile-time programmingPerformance and optimization
Real-World C++ InterviewsLesson 97
Question 097: How would you add functionality to your classes with the Curiously Recurring Template Pattern (CRTP)?
JuniorMiddle
Object-oriented design and APIsTemplates and compile-time programming
Real-World C++ InterviewsLesson 98
Question 098: What are the good reasons to use init() functions to initialize an object?
Middle
Object-oriented design and APIsDebugging and correctness
Real-World C++ InterviewsLesson 99
Question 099: What is observable behaviour of code?
JuniorMiddle
Language fundamentalsPerformance and optimization
Real-World C++ InterviewsLesson 100
Question 100: What are the characteristics of an ill-formed C++ program?
Junior
Language fundamentalsDebugging and correctness
Real-World C++ InterviewsLesson 101
Question 101: What is unspecified behaviour?
FresherJunior
Language fundamentalsDebugging and correctness
Real-World C++ InterviewsLesson 102
Question 102: What is implementation-defined behaviour?
FresherJunior
Language fundamentalsBuild, I/O, and systems
Real-World C++ InterviewsLesson 103
Question 103: What is undefined behaviour in C++?
FresherJunior
Language fundamentalsDebugging and correctness
Real-World C++ InterviewsLesson 104
Question 104: What are the reasons behind undefined behaviour’s existence?
JuniorMiddle
Language fundamentalsPerformance and optimization
Real-World C++ InterviewsLesson 105
Question 105: What approaches to take to avoid undefined behaviour?
Junior
Memory management and lifetimeDebugging and correctness
Real-World C++ InterviewsLesson 106
Question 106: What is iterator invalidation? Give a few examples.
FresherJunior
Memory management and lifetimeStandard library and containers
Real-World C++ InterviewsLesson 107
Question 107: What is the STL?
InternFresher
Standard library and containers
Real-World C++ InterviewsLesson 108
Question 108: What are the advantages of algorithms over raw loops?
FresherJunior
Standard library and containers
Real-World C++ InterviewsLesson 109
Question 109: Do algorithms validate ranges?
FresherJunior
Standard library and containersDebugging and correctness
Real-World C++ InterviewsLesson 110
Question 110: Can you combine containers of different sizes?
Junior
Standard library and containersDebugging and correctness
Real-World C++ InterviewsLesson 111
Question 111: How is a vector’s memory layout organized?
FresherJunior
Memory management and lifetimeStandard library and containers
Real-World C++ InterviewsLesson 112
Question 112: Can we inherit from a standard container (such as std::vector)? If so what are the implications?
JuniorMiddle
Object-oriented design and APIsStandard library and containers
Real-World C++ InterviewsLesson 113
Question 113: What is the type of myCollection after the following declaration?
InternFresher
Language fundamentals
Real-World C++ InterviewsLesson 114
Question 114: What are the advantages of const_iterators over iterators?
FresherJunior
Standard library and containers
Real-World C++ InterviewsLesson 115
Question 115: Binary search an element with algorithms!
FresherJunior
Standard library and containersDebugging and correctness
Real-World C++ InterviewsLesson 116
Question 116: What is an Iterator class?
FresherJunior
Standard library and containersTemplates and compile-time programming
Real-World C++ InterviewsLesson 117
Question 117: Can you call a virtual function from a constructor or a destructor?
Junior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 118
Question 118: What are default arguments? How are they evaluated in a C++ function?
Junior
Language fundamentalsObject-oriented design and APIs
Real-World C++ InterviewsLesson 119
Question 119: Can virtual functions have default arguments?
JuniorMiddle
Object-oriented design and APIsDebugging and correctness
Real-World C++ InterviewsLesson 120
Question 120: Should base class destructors be virtual?
Junior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 121
Question 121: What is the function of the keyword mutable?
Junior
Language fundamentalsObject-oriented design and APIs
Real-World C++ InterviewsLesson 122
Question 122: What is the function of the keyword volatile?
JuniorMiddle
Concurrency and memory modelBuild, I/O, and systems
Real-World C++ InterviewsLesson 123
Question 123: What is an inline function?
FresherJunior
Language fundamentalsBuild, I/O, and systems
Real-World C++ InterviewsLesson 124
Question 124: What do we catch?
FresherJunior
Object-oriented design and APIsDebugging and correctness
Real-World C++ InterviewsLesson 125
Question 125: What are the differences between references and pointers?
InternFresher
Language fundamentalsMemory management and lifetime
Real-World C++ InterviewsLesson 126
Question 126: Which of the following variable declarations compile and what would be the value of a?
FresherJunior
Language fundamentalsDebugging and correctness
Real-World C++ InterviewsLesson 127
Question 127: What will the line of code below print out and why?
FresherJunior
Language fundamentalsDebugging and correctness
Real-World C++ InterviewsLesson 128
Question 128: Explain the difference between pre- and post increment/decrement operators
InternFresher
Language fundamentals
Real-World C++ InterviewsLesson 129
Question 129: What are the final values of a, b and c?
InternFresher
Language fundamentals
Real-World C++ InterviewsLesson 130
Question 130: Does this string declaration compile?
FresherJunior
Language fundamentalsBuild, I/O, and systems
Real-World C++ InterviewsLesson 131
Question 131: What are Default Member Initializers in C++?
FresherJunior
Object-oriented design and APIs
Real-World C++ InterviewsLesson 132
Question 132: What is the most vexing parse?
FresherJunior
Language fundamentalsDebugging and correctness
Real-World C++ InterviewsLesson 133
Question 133: Does this code compile? If yes, what does it do? If not, why not?
FresherJunior
Language fundamentalsDebugging and correctness
Real-World C++ InterviewsLesson 134
Question 134: What is std::string_view and why should we use it?
Junior
Memory management and lifetimeStandard library and containers
Real-World C++ InterviewsLesson 135
Question 135: How to check if a string starts or ends with a certain substring?
InternFresher
Standard library and containers
Real-World C++ InterviewsLesson 136
Question 136: What is RVO?
JuniorMiddle
Language fundamentalsPerformance and optimization
Real-World C++ InterviewsLesson 137
Question 137: How can we ensure the compiler performs RVO?
Junior
Language fundamentalsPerformance and optimization
Real-World C++ InterviewsLesson 138
Question 138: What are the primary and mixed value categories in C++?
Junior
Language fundamentalsTemplates and compile-time programming
Real-World C++ InterviewsLesson 139
Question 139: Can you safely compare signed and unsigned integers?
Junior
Language fundamentalsDebugging and correctness
Real-World C++ InterviewsLesson 140
Question 140: What is the return value of main and what are the available signatures?
InternFresher
Language fundamentalsBuild, I/O, and systems
Real-World C++ InterviewsLesson 141
Question 141: Should you prefer default arguments or overloading?
Middle
Object-oriented design and APIsBuild, I/O, and systems
Real-World C++ InterviewsLesson 142
Question 142: How many variables should you declare on a line?
InternFresher
Language fundamentals
Real-World C++ InterviewsLesson 143
Question 143: Should you prefer a switch statement or chained if statements?
FresherJunior
Language fundamentals
Real-World C++ InterviewsLesson 144
Question 144: What are include guards?
InternFresher
Build, I/O, and systems
Real-World C++ InterviewsLesson 145
Question 145: Should you use angle brackets(<filename>) or double quotes(“filename”) to include?
InternFresher
Build, I/O, and systems
Real-World C++ InterviewsLesson 146
Question 146: How many return statements should you have in a function?
FresherJunior
Object-oriented design and APIs
Real-World C++ InterviewsLesson 148
Question 148: What are access modifiers in C++?
InternFresher
Object-oriented design and APIs
Real-World C++ InterviewsLesson 149
Question 149: What is std in C++?
InternFresher
Language fundamentalsStandard library and containers
Real-World C++ InterviewsLesson 150
Question 150: What is a pointer in C++, and how is it different from a reference?
InternFresher
Language fundamentalsMemory management and lifetime
Real-World C++ InterviewsLesson 151
Question 151: What is the difference between stack memory and heap memory?
FresherJunior
Memory management and lifetimePerformance and optimization
Real-World C++ InterviewsLesson 152
Question 152: What is the difference between pass by value and pass by reference?
FresherJunior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 153
Question 153: Explain shallow copy, deep copy, and the copy constructor in C++.
FresherJunior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 154
Question 154: What is a recursive function? Provide an example.
InternFresher
Language fundamentalsDebugging and correctness
Real-World C++ InterviewsLesson 155
Question 155: What is function overloading in C++ (compile-time polymorphism)?
FresherJunior
Language fundamentalsObject-oriented design and APIs
Real-World C++ InterviewsLesson 156
Question 156: What is the difference between struct and class in C++?
InternFresher
Object-oriented design and APIs
Real-World C++ InterviewsLesson 157
Question 157: What are the auto and decltype keywords used for?
FresherJunior
Language fundamentalsTemplates and compile-time programming
Real-World C++ InterviewsLesson 158
Question 158: What is a friend function?
FresherJunior
Object-oriented design and APIs
Real-World C++ InterviewsLesson 159
Question 159: What is object slicing in C++? How can you avoid it?
JuniorMiddle
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 160
Question 160: What is the difference between an abstract class and an interface in C++? How do you implement interface-like behavior?
FresherJunior
Object-oriented design and APIsTemplates and compile-time programming
Real-World C++ InterviewsLesson 161
Question 161: Explain encapsulation with an example.
FresherJunior
Object-oriented design and APIs
Real-World C++ InterviewsLesson 162
Question 162: What is multiple inheritance, and what problems can it cause?
JuniorMiddle
Object-oriented design and APIs
Real-World C++ InterviewsLesson 163
Question 163: What is the difference between static data members and normal data members?
InternFresher
Object-oriented design and APIs
Real-World C++ InterviewsLesson 164
Question 164: What is the this pointer, and how is it used?
FresherJunior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 165
Question 165: What is function overriding in C++, and how does the base class affect it?
Junior
Object-oriented design and APIsDebugging and correctness
Real-World C++ InterviewsLesson 166
Question 166: What is a function pointer, and how do you use it?
FresherJunior
Language fundamentalsObject-oriented design and APIs
Real-World C++ InterviewsLesson 167
Question 167: How does inline expansion of functions affect performance?
JuniorMiddle
Performance and optimizationBuild, I/O, and systems
Real-World C++ InterviewsLesson 168
Question 168: How is exception handling implemented in C++?
FresherJunior
Memory management and lifetimeDebugging and correctness
Real-World C++ InterviewsLesson 169
Question 169: What is the difference between std::exception and user-defined exceptions?
FresherJunior
Object-oriented design and APIsDebugging and correctness
Real-World C++ InterviewsLesson 171
Question 171: Explain templates in C++ and provide a simple example.
FresherJunior
Templates and compile-time programming
Real-World C++ InterviewsLesson 172
Question 172: What is the Standard Template Library (STL)? Name some commonly used containers.
FresherJunior
Standard library and containers
Real-World C++ InterviewsLesson 173
Question 173: What are lambda expressions in C++11 and later?
FresherJunior
Language fundamentals
Real-World C++ InterviewsLesson 174
Question 174: What are move semantics in C++11, and why are they important?
Junior
Memory management and lifetimePerformance and optimization
Real-World C++ InterviewsLesson 175
Question 175: What are lvalues and rvalues?
Junior
Language fundamentalsTemplates and compile-time programming
Real-World C++ InterviewsLesson 177
Question 177: What does abstraction mean in C++, and which language mechanisms help enforce it?
JuniorMiddle
Object-oriented design and APIsBuild, I/O, and systems
Real-World C++ InterviewsLesson 178
Question 178: How does C++ classify fundamental and compound types, and where do enums and class types fit?
InternFresher
Language fundamentals
Real-World C++ InterviewsLesson 179
Question 179: What does inheritance model in C++, and what is and is not inherited by a derived class?
FresherJunior
Object-oriented design and APIs
Real-World C++ InterviewsLesson 180
Question 180: What is a constructor, and what distinguishes it from an ordinary member function?
FresherJunior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 181
Question 181: What is operator overloading, which operators cannot be overloaded, and what semantics should overloads preserve?
Junior
Language fundamentalsObject-oriented design and APIs
Real-World C++ InterviewsLesson 182
Question 182: What is the distinction between a class definition, an object, and an object's lifetime?
FresherJunior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 183
Question 183: In what order are virtual bases, direct bases, data members, and the constructor body initialized, and what is the destruction order?
Junior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 184
Question 184: What can and cannot be done safely through void*, and when should a typed alternative be preferred?
JuniorMiddle
Memory management and lifetimeBuild, I/O, and systems
Real-World C++ InterviewsLesson 185
Question 185: How is memory-mapped I/O accessed in embedded C++, and what do volatile, alignment, and platform ordering guarantees each provide?
Middle
Concurrency and memory modelBuild, I/O, and systems
Real-World C++ InterviewsLesson 186
Question 186: What is endianness, and how should C++ decode fixed-format or network data without aliasing or alignment bugs?
JuniorMiddle
Debugging and correctnessBuild, I/O, and systems
Real-World C++ InterviewsLesson 187
Question 187: How do RTOS-based and bare-metal C++ designs differ in scheduling, latency, ownership, and failure modes?
MiddleSenior
Concurrency and memory modelPerformance and optimizationBuild, I/O, and systems
Real-World C++ InterviewsLesson 188
Question 188: What constraints apply to C++ code in an ISR, and how should data be handed off safely to normal execution?
MiddleSenior
Concurrency and memory modelBuild, I/O, and systems
Real-World C++ InterviewsLesson 189
Question 189: How do std::map and std::unordered_map differ in ordering, complexity guarantees, invalidation, memory use, and worst cases?
JuniorMiddle
Standard library and containersPerformance and optimization
Real-World C++ InterviewsLesson 190
Question 190: When should static_cast, dynamic_cast, const_cast, and reinterpret_cast be used, and what risks does each carry?
Junior
Language fundamentalsDebugging and correctness
Real-World C++ InterviewsLesson 191
Question 191: What iterator categories and concepts exist in modern C++, and how do their guarantees constrain algorithms?
JuniorMiddle
Standard library and containersTemplates and compile-time programming
Real-World C++ InterviewsLesson 192
Question 192: When is std::atomic appropriate, when is a mutex required, and why is lock-free operation not guaranteed?
Middle
Concurrency and memory model
Real-World C++ InterviewsLesson 193
Question 193: What conditions produce deadlock, and how do lock ordering and std::scoped_lock help prevent it?
JuniorMiddle
Concurrency and memory modelDebugging and correctness
Real-World C++ InterviewsLesson 194
Question 194: What is the difference between a C++ data race and a higher-level race condition, and how do you prevent each?
Middle
Concurrency and memory modelDebugging and correctness
Real-World C++ InterviewsLesson 195
Question 195: How do std::mutex, std::lock_guard, std::unique_lock, and std::scoped_lock differ?
Junior
Memory management and lifetimeConcurrency and memory model
Real-World C++ InterviewsLesson 196
Question 196: How should std::thread lifecycle be managed with join or detach, and when is std::jthread safer?
JuniorMiddle
Memory management and lifetimeConcurrency and memory model
Real-World C++ InterviewsLesson 197
Question 197: How do composition, non-owning aggregation, and inheritance differ in ownership, lifetime, and substitutability?
JuniorMiddle
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 198
Question 198: How can template recursion compute a value at compile time, and when is a constexpr function preferable?
JuniorMiddle
Templates and compile-time programmingPerformance and optimization
Real-World C++ InterviewsLesson 199
Question 199: What are template-template parameters, and how do parameter matching and defaults affect accepted templates?
Middle
Templates and compile-time programmingBuild, I/O, and systems
Real-World C++ InterviewsLesson 200
Question 200: How do variadic templates, parameter-pack expansion, and fold expressions work, including for an empty pack?
JuniorMiddle
Language fundamentalsTemplates and compile-time programming
Real-World C++ InterviewsLesson 201
Question 201: How do dependent names and two-phase lookup determine when typename, template, or this-> is required?
JuniorMiddle
Language fundamentalsTemplates and compile-time programming
Real-World C++ InterviewsLesson 202
Question 202: What are expression templates, and what performance and lifetime trade-offs come with deferred evaluation?
MiddleSenior
Memory management and lifetimeTemplates and compile-time programmingPerformance and optimization
Real-World C++ InterviewsLesson 203
Question 203: How do std::is_base_of and std::derived_from differ for private or ambiguous inheritance?
JuniorMiddle
Object-oriented design and APIsTemplates and compile-time programming
Real-World C++ InterviewsLesson 204
Question 204: Which user-declared special members suppress implicit copy or move operations, and when should =default or =delete be explicit?
JuniorMiddle
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 205
Question 205: Why can std::move on a const object select a copy or fail instead of moving?
Junior
Language fundamentalsMemory management and lifetime
Real-World C++ InterviewsLesson 206
Question 206: Which expressions defeat perfect forwarding, and how should an API handle them?
Middle
Object-oriented design and APIsTemplates and compile-time programming
Real-World C++ InterviewsLesson 207
Question 207: What does std::move_if_noexcept select, and how can it help generic code preserve exception guarantees?
JuniorMiddle
Memory management and lifetimeDebugging and correctness
Real-World C++ InterviewsLesson 208
Question 208: What guarantees do the C++ atomic memory orders provide, and when is relaxed ordering sufficient?
Middle
Concurrency and memory model
Real-World C++ InterviewsLesson 209
Question 209: How do sequenced-before, synchronizes-with, and happens-before make release/acquire publication safe?
Middle
Concurrency and memory modelDebugging and correctness
Real-World C++ InterviewsLesson 210
Question 210: What is the ABA problem in compare-exchange algorithms, and which tagging or reclamation strategies address it?
MiddleSenior
Memory management and lifetimeConcurrency and memory model
Real-World C++ InterviewsLesson 211
Question 211: How do compare_exchange_weak and compare_exchange_strong differ, and when should each be used?
JuniorMiddle
Concurrency and memory model
Real-World C++ InterviewsLesson 212
Question 212: How do atomic fences establish synchronization, and why is a fence without an atomic rendezvous insufficient?
MiddleSenior
Concurrency and memory modelDebugging and correctness
Real-World C++ InterviewsLesson 213
Question 213: How do structured bindings bind arrays, tuple-like types, and class members, and when are the bindings references?
Junior
Language fundamentalsStandard library and containers
Real-World C++ InterviewsLesson 214
Question 214: When should std::optional model absence instead of a pointer or sentinel, and what access and lifetime pitfalls remain?
Junior
Memory management and lifetimeObject-oriented design and APIsStandard library and containers
Real-World C++ InterviewsLesson 215
Question 215: What does if constexpr discard, and which syntax or name checks still apply to the discarded branch?
JuniorMiddle
Language fundamentalsTemplates and compile-time programming
Real-World C++ InterviewsLesson 216
Question 216: How does std::variant manage its active alternative, and how should std::visit, get, and get_if be used safely?
JuniorMiddle
Standard library and containersDebugging and correctness
Real-World C++ InterviewsLesson 217
Question 217: What guarantees does std::span provide as a non-owning contiguous view, and what lifetime and bounds risks remain?
Junior
Memory management and lifetimeStandard library and containers
Real-World C++ InterviewsLesson 218
Question 218: How do std::mutex, std::recursive_mutex, and std::shared_mutex differ, and when is each appropriate?
Middle
Concurrency and memory modelPerformance and optimization
Real-World C++ InterviewsLesson 220
Question 220: How do promise, future, shared_future, and async communicate values and exceptions, and what lifecycle traps matter?
Middle
Memory management and lifetimeConcurrency and memory model
Real-World C++ InterviewsLesson 221
Question 221: What lifetime, initialization, and destruction guarantees does thread_local provide, and what costs can it introduce?
Middle
Memory management and lifetimeConcurrency and memory modelPerformance and optimization
Real-World C++ InterviewsLesson 222
Question 222: How do custom deleters affect unique_ptr and shared_ptr type, size, control blocks, and C-API integration?
JuniorMiddle
Memory management and lifetimeBuild, I/O, and systems
Real-World C++ InterviewsLesson 223
Question 223: What preconditions does enable_shared_from_this impose, and when is weak_from_this safer for callbacks?
JuniorMiddle
Memory management and lifetimeConcurrency and memory model
Real-World C++ InterviewsLesson 224
Question 224: How do empty-base optimization and [[no_unique_address]] reduce storage, and what address or layout constraints remain?
Middle
Object-oriented design and APIsPerformance and optimizationBuild, I/O, and systems
Real-World C++ InterviewsLesson 225
Question 225: What happens when a destructor lets an exception escape, especially during stack unwinding?
JuniorMiddle
Memory management and lifetimeDebugging and correctness
Real-World C++ InterviewsLesson 226
Question 226: How does copy-and-swap provide assignment safety, and what performance or design trade-offs does it have?
JuniorMiddle
Object-oriented design and APIsPerformance and optimizationDebugging and correctness
Real-World C++ InterviewsLesson 227
Question 227: How does argument-dependent lookup work, and why does the using std::swap; swap(a, b); idiom matter?
JuniorMiddle
Standard library and containersTemplates and compile-time programming
Real-World C++ InterviewsLesson 228
Question 228: How does copy-on-write work, and why is it usually unsuitable for modern std::string-style value types?
MiddleSenior
Memory management and lifetimeObject-oriented design and APIsConcurrency and memory model
Real-World C++ InterviewsLesson 229
Question 229: How should a user-provided derived copy or move constructor initialize its base subobject?
Junior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 230
Question 230: Which subobjects are destroyed when construction throws, and how does RAII make construction exception-safe?
Junior
Memory management and lifetimeDebugging and correctness
Real-World C++ InterviewsLesson 231
Question 231: What is small-string optimization, which properties are implementation-defined, and when can it affect performance?
JuniorMiddle
Standard library and containersPerformance and optimization
Real-World C++ InterviewsLesson 232
Question 232: How do push_back and emplace_back differ in construction, conversions, exceptions, and invalidation?
Junior
Standard library and containersDebugging and correctness
Real-World C++ InterviewsLesson 233
Question 233: Why is std::vector<bool> special, and how do proxy references affect generic or concurrent code?
JuniorMiddle
Standard library and containersConcurrency and memory model
Real-World C++ InterviewsLesson 234
Question 234: How do vector::reserve and vector::resize differ in size, capacity, construction, and iterator invalidation?
FresherJunior
Memory management and lifetimeStandard library and containers
Real-World C++ InterviewsLesson 235
Question 235: How do load factor, hash quality, reserve, and rehash affect unordered_map complexity and invalidation?
JuniorMiddle
Standard library and containersPerformance and optimization
Real-World C++ InterviewsLesson 236
Question 236: How should insertion complexity, search cost, cache locality, and invalidation guide container choice?
MiddleSenior
Standard library and containersPerformance and optimization
Real-World C++ InterviewsLesson 237
Question 237: Can constexpr functions contain try or throw, and what happens if a throwing path is taken during constant evaluation?
JuniorMiddle
Templates and compile-time programmingDebugging and correctness
Real-World C++ InterviewsLesson 238
Question 238: What contract does the C++23 [[assume]] attribute make, and why is a false assumption undefined behavior?
Middle
Language fundamentalsPerformance and optimizationDebugging and correctness
Real-World C++ InterviewsLesson 239
Question 239: What does final mean on a virtual function versus a class, and when is it appropriate?
JuniorMiddle
Object-oriented design and APIs
Real-World C++ InterviewsLesson 240
Question 240: How does non-virtual name hiding differ from overriding, and how do override or using-declarations expose mistakes?
Junior
Object-oriented design and APIsDebugging and correctness
Real-World C++ InterviewsLesson 241
Question 241: What does RTTI provide through typeid and dynamic_cast, when is polymorphism required, and when is virtual dispatch better?
JuniorMiddle
Object-oriented design and APIsBuild, I/O, and systems
Real-World C++ InterviewsLesson 242
Question 242: Why must new/delete and new[]/delete[] be paired correctly, and which RAII alternatives avoid the issue?
FresherJunior
Memory management and lifetimeDebugging and correctness
Real-World C++ InterviewsLesson 243
Question 243: What are name mangling and language linkage, and what does extern C guarantee or not guarantee across an ABI?
MiddleSenior
Object-oriented design and APIsBuild, I/O, and systems
Real-World C++ InterviewsLesson 244
Question 244: What does C++'s zero-overhead principle actually claim, and when can an abstraction still impose runtime or code-size cost?
Middle
Object-oriented design and APIsPerformance and optimization
Real-World C++ InterviewsLesson 245
Question 245: How do headers and source files form translation units, and which declarations or definitions may live in headers without violating the ODR?
FresherJunior
Build, I/O, and systems
Real-World C++ InterviewsLesson 246
Question 246: How do namespaces prevent collisions, and what risks do namespace aliases, using-declarations, and using-directives introduce—especially in headers?
Junior
Language fundamentalsBuild, I/O, and systems
Real-World C++ InterviewsLesson 247
Question 247: How do assignment (=) and equality comparison (==) differ in expressions, and why can accidental assignment in a condition compile?
InternFresher
Language fundamentalsDebugging and correctness
Real-World C++ InterviewsLesson 248
Question 248: How would you diagnose a reproducible C++ crash or undefined behavior using warnings, a debugger, sanitizers, and a minimized test?
JuniorMiddle
Debugging and correctnessBuild, I/O, and systems
Real-World C++ InterviewsLesson 249
Question 249: What trade-offs do exceptions have versus status- or expected-style error returns, especially at ABI, real-time, and latency-sensitive boundaries?
MiddleSenior
Performance and optimizationDebugging and correctnessBuild, I/O, and systems
Real-World C++ InterviewsLesson 250
Question 250: How do new/delete, operator new, and malloc/free differ in storage allocation, object lifetime, construction, failure, alignment, and replacement?
JuniorMiddle
Memory management and lifetimeBuild, I/O, and systems
Real-World C++ InterviewsLesson 251
Question 251: When should a C++ system use an allocator-aware container, std::pmr::memory_resource, or a custom memory pool, and what latency, locality, fragmentation, lifetime, and synchronization trade-offs follow?
MiddleSenior
Memory management and lifetimeConcurrency and memory modelPerformance and optimization
Real-World C++ InterviewsLesson 252
Question 252: How would you design a C++ thread pool with a protected work queue, condition-variable predicates, orderly shutdown, task-result/exception propagation, and backpressure?
MiddleSenior
Object-oriented design and APIsConcurrency and memory model
Real-World C++ InterviewsLesson 253
Question 253: What is false sharing, how can you detect it, and how should cache-line-aware layout mitigate it without hard-coding assumptions?
MiddleSenior
Concurrency and memory modelPerformance and optimization
Real-World C++ InterviewsLesson 255
Question 255: How do hazard pointers make lock-free memory reclamation safe, and when are they preferable to reference counting or epoch-based reclamation?
MiddleSenior
Memory management and lifetimeConcurrency and memory model
Real-World C++ InterviewsLesson 256
Question 256: How do array-of-structures and structure-of-arrays layouts affect cache locality, vectorization, and workload-specific performance?
MiddleSenior
Memory management and lifetimePerformance and optimization
Real-World C++ InterviewsLesson 257
Question 257: How do branch prediction and misprediction affect a hot loop, and when can restructuring or [[likely]]/[[unlikely]] help?
Middle
Performance and optimizationDebugging and correctness
Real-World C++ InterviewsLesson 259
Question 259: How do formatted extraction and std::getline interact, and how should code handle leftover delimiters, EOF, parse failure, and stream recovery?
FresherJunior
Debugging and correctnessBuild, I/O, and systems
Real-World C++ InterviewsLesson 260
Question 260: When should C++ code use from_chars/to_chars, stoi/to_string, or string streams for text-number conversion, and how should it validate complete input?
JuniorMiddle
Debugging and correctnessBuild, I/O, and systems
Real-World C++ InterviewsLesson 261
Question 261: How should C++ write files robustly with RAII streams, open modes, state checks, explicit close handling, and text-versus-binary semantics?
MiddleSenior
Debugging and correctnessBuild, I/O, and systems
Real-World C++ InterviewsLesson 262
Question 262: How do C++ random engines, distributions, seeding, reproducibility, modulo bias, thread use, and security requirements fit together?
JuniorMiddle
Concurrency and memory modelDebugging and correctnessBuild, I/O, and systems
Real-World C++ InterviewsLesson 264
Question 264: When should dynamic two-dimensional data use nested vectors, flat contiguous storage, or a non-owning multidimensional view?
JuniorMiddle
Memory management and lifetimeStandard library and containersPerformance and optimization
Real-World C++ InterviewsLesson 265
Question 265: How do internal, external, and no linkage determine whether declarations across scopes or translation units denote the same C++ entity?
JuniorMiddle
Language fundamentalsBuild, I/O, and systems
Real-World C++ InterviewsLesson 266
Question 266: What scope and object-lifetime rules constrain goto in C++, and when can it be justified instead of structured control flow?
Junior
Language fundamentalsMemory management and lifetime
Real-World C++ InterviewsLesson 267
Question 267: How do placement construction, alignment, explicit destruction, transparent replacement, and storage reuse interact with C++ object lifetime?
Middle
Memory management and lifetimeDebugging and correctness
Real-World C++ InterviewsLesson 268
Question 268: What mutation, bounds, null-termination, contiguity, and invalidation guarantees does std::string provide through operator[], at(), data(), and mutating operations?
FresherJunior
Memory management and lifetimeStandard library and containers
Real-World C++ InterviewsLesson 269
Question 269: What does the C++ preprocessor do, and when should macros be replaced with constexpr values, inline functions, templates, or scoped constants?
FresherJunior
Language fundamentalsBuild, I/O, and systems
Real-World C++ InterviewsLesson 270
Question 270: How do signed integer overflow, unsigned modulo arithmetic, integer promotions, narrowing, and checked arithmetic differ in C++?
JuniorMiddle
Language fundamentalsDebugging and correctness
Real-World C++ InterviewsLesson 271
Question 271: What happens during preprocessing, compilation, and linking, and why can a translation unit without main compile while a hosted executable fails to link?
InternFresher
Build, I/O, and systems
Real-World C++ InterviewsLesson 272
Question 272: How do std::array and std::vector differ in extent, storage ownership, object size, moves, allocation, and invalidation?
FresherJunior
Memory management and lifetimeStandard library and containers
Real-World C++ InterviewsLesson 273
Question 273: What guarantees and hazards come with C-style variadic functions using ellipsis and va_list, and when should variadic templates be preferred?
JuniorMiddle
Templates and compile-time programmingBuild, I/O, and systems
Real-World C++ InterviewsLesson 274
Question 274: Why should constructors initialize bases and members in the member-initializer list instead of assigning in the body, and which subobjects require it?
FresherJunior
Memory management and lifetimeObject-oriented design and APIs
Real-World C++ InterviewsLesson 275
Question 275: How do standard conversions, user-defined conversions, explicit conversions, and narrowing participate in overload resolution?
JuniorMiddle
Language fundamentalsObject-oriented design and APIs
Real-World C++ InterviewsLesson 276
Question 276: When should an API use a function pointer, templated callable, lambda or functor, or std::function, and what trade-offs follow for state, lifetime, allocation, and optimization?
MiddleSenior
Memory management and lifetimeObject-oriented design and APIsTemplates and compile-time programmingPerformance and optimization
Real-World C++ InterviewsLesson 277
Question 277: What roles do Make and CMake play in a C++ build, and how should target dependencies and transitive usage requirements be modeled?
JuniorMiddle
Build, I/O, and systems