DEVPREP CODEX · #16

OOPs Interview Questions

150 curated questions graded from Foundations (Easy) to Practical Patterns (Medium) and Internals & Architecture (Hard).

TOTAL QUESTIONS

150

THEORY QUESTIONS

150

IMPLEMENTATION FOLIOS

FREE QUESTIONS

5 / Level

Easy Level·50 Questions Total

Foundations & Core Concepts

Open Full Easy List

Q1What is Object-Oriented Programming (OOP) and how does it differ from procedural programming?

OOP: A paradigm organizing software around objects (data combined with behavior) rather than actions or pure logic.
Procedural: Organizes software sequentially around functions or procedures processing separate, detached data.
Key Differences: OOP promotes encapsulation, data security, code reuse, and modularity; Procedural is prone to global state mutation and harder to maintain as systems scale.

Q2What is a Class and how does it differ from an Object?

Class: A static blueprint, template, or user-defined data type that defines variables (state) and methods (behavior) common to all objects of its kind.
Object: A dynamic, runtime instance of a class. It occupies physical memory and holds specific values for the defined variables.
Analogy: A class is a house blueprint; an object is the physical house built from that blueprint.

Q3Explain the concept of Encapsulation and its primary benefits.

Definition: The grouping of data (attributes) and the methods (behavior) that operate on that data into a single unit (class), while restricting direct access to some of the object's components.
Benefits:
- Data Hiding: Prevents unauthorized modifications of internal state.
- Flexibility/Maintainability: Internal class implementation can change without affecting external callers.
- Control: Allows validation of inputs via getter and setter methods.

Q4What is Abstraction in OOP, and how is it different from Encapsulation?

Abstraction: The process of hiding complex implementation details and showing only the essential features to the outside world. It answers what an object does rather than how it does it.
Encapsulation: The process of binding data and code together and hiding the internal details (information hiding).
Difference: Abstraction is a design-level concept focused on reducing complexity; Encapsulation is an implementation-level concept focused on securing and hiding data.

Q5What is Inheritance, and what problem does it solve?

Definition: A mechanism where a new class (subclass/child) acquires the properties and behaviors of an existing class (superclass/parent).
Problems Solved:
- Code Redundancy: Avoids rewriting common code across multiple classes.
- Polymorphism Support: Establishes an "Is-A" relationship, enabling dynamic method dispatch.
- Extensibility: Enhances existing functionality without modifying the original code.

45 More Easy Questions Locked

Unlock the complete OOPs Easy question bank

Get instant access to all 50 questions, in-depth model answers, code sandboxes, and all 27+ technologies for a single one-time payment.

Unlock All — One-time payment · Lifetime access

Medium Level·50 Questions Total

Mechanisms & Practical Patterns

Open Full Medium List

Q1How do abstract classes and interfaces differ in terms of architectural design intent?

Abstract Class (Identity): Establishes an "Is-A" relationship. It represents a strict taxonomic lineage, sharing core structural state and common base implementations. Use it when subclasses are fundamentally related.
Interface (Capability): Establishes a "Can-Do" contract. It defines a protocol or behavioral capability that can be implemented by entirely unrelated classes. Use it to support horizontal decoupling.

Q2What is dynamic method dispatch, and how does the runtime resolve which method to call?

Definition: The mechanism where a call to an overridden method is resolved at runtime instead of compile-time.
Resolution Process: The runtime inspects the actual object instance in memory (not the reference pointer type). It uses the object's internal type metadata to lookup and execute the specific overriding method defined in that object's class.

Q3What is the Virtual Method Table (VTable) and how is dynamic dispatch implemented under the hood?

VTable: A lookup table of function pointers created by the compiler for any class containing virtual methods. Each class has exactly one static VTable.
VPTR: An implicit pointer added to the memory layout of each object instance pointing to its class's VTable.
Resolution: During a virtual call, the compiled code dereferences the object's VPTR, navigates to the class's VTable, and jumps to the function pointer at the designated offset. This adds a slight runtime overhead of double-indirection.

Q4What is object slicing in C++, and why does it not occur in languages like Java or C#?

Object Slicing: Occurs in C++ when a subclass object is assigned by-value to a parent class object. The subclass-specific member variables are "sliced away" because the parent object's memory footprint is too small.
Java/C# Exemption: These languages handle objects exclusively by-reference on the heap. Assigning a subclass reference to a parent reference only copies the reference pointer, not the underlying object data.

Q5Explain the difference between early (static) binding and late (dynamic) binding.

Early Binding: Occurs at compile-time. The compiler matches method calls directly to specific memory addresses. It is fast, highly optimizable, and applies to static, private, and final methods.
Late Binding: Occurs at runtime. The target method is resolved dynamically using virtual tables. It supports polymorphism but incurs slight indirection overhead.

45 More Medium Questions Locked

Unlock the complete OOPs Medium question bank

Get instant access to all 50 questions, in-depth model answers, code sandboxes, and all 27+ technologies for a single one-time payment.

Unlock All — One-time payment · Lifetime access

Hard Level·50 Questions Total

Internals & System Architecture

Open Full Hard List

Q1How does multiple inheritance work in C++ under the hood in terms of memory layouts and virtual base classes?

Memory Layout: When Class C inherits from Class A and Class B, the memory layout of C contains the member variables of A, followed by the variables of B, and then the variables of C. This means there are two distinct VPTRs inside C (one pointing to a VTable for A, and one for B).
Virtual Base Classes: To resolve duplicate grandparent fields (the Diamond Problem), C++ uses virtual inheritance. A virtual base class's members are placed at the very end of the object's layout, and accessing them requires a virtual-base offset lookup inside the VTable, avoiding duplicate subobjects.

Q2What is pointer offset adjustment in C++ multiple inheritance during upcasting?

Adjustment: Under multiple inheritance, casting a derived pointer C* to a base pointer B* (where B is the second parent) requires the compiler to add a byte offset to the pointer address.
Reason: The base subobject B does not start at the beginning of the object memory layout of C. When calling B's methods, the this pointer must be adjusted to point directly to B's start address; otherwise, B's methods would read A's variables as if they were B's.

Q3Explain Covariance, Contravariance, and Invariance in the context of generic types and method overrides.

Covariance: Allows a type to be substituted with its subtype (e.g., List<? extends Animal>). Reading is safe because everything returned is an Animal, but writing is unsafe.
Contravariance: Allows a type to be substituted with its supertype (e.g., List<? super Dog>). Writing is safe because you can write a Dog or its subclass, but reading only yields Object.
Invariance: No substitutions allowed (e.g., List<Animal>). You can only assign exactly the declared type.

Q4How do compilers optimize dynamic dispatch calls via devirtualization?

Devirtualization: The compiler converts a virtual method call (which requires VTable indirection) into a direct static call.
Analysis Techniques:
- Class Hierarchy Analysis (CHA): Looks at the entire loaded class hierarchy to see if a virtual method is overridden by any subclasses. If only one implementation exists, it devirtualizes it.
- Escape Analysis: Determines if an object escapes the local scope. If it doesn't, the compiler knows its exact type and can resolve calls statically.

Q5What are Monomorphic, Oligomorphic, and Megamorphic call sites in dynamic dispatch optimization?

Monomorphic: A call site that encounters exactly one receiver type. Optimized via direct inlining.
Oligomorphic: Encounters a small, fixed number of receiver types (usually up to 3 or 4). Optimized using a conditional check (MIP/Polymorphic Inline Cache).
Megamorphic: Encounters a massive number of distinct receiver types. Requires falling back to the full VTable lookup, which is slow.

45 More Hard Questions Locked