Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
Object Oriented Programming · Question Set
Constructors, Destructors & Memory Management interview questions for placements and exams.
Questions
12
Included in this set
Subject
Object Oriented Programming
Explore more sets
Difficulty
Mixed
Level of this set
Go through each question and its explanation. Use this set as a focused practice pack for Object Oriented Programming.
A constructor is a special method of a class that is called when a new object is created. Its job is to initialize the new object’s state—setting up fields, allocating resources, or performing setup tasks so that the object is ready to use.
For complete preparation, combine this set with full subject-wise practice for Object Oriented Programming. You can also explore other subjects and sets from the links below.
A default constructor takes no arguments. Many OOP languages (for example Java or C++ when no constructor is defined) will automatically provide a default no-argument constructor to allow object creation without explicit parameters.
A parameterised constructor allows you to supply initial values for the object’s fields at the time of creation. This helps set up the object in the correct state from the outset and avoid separate setter calls afterwards.
A copy constructor in C++ allows you to create a new object by copying the content of an existing object. It handles duplication of fields (shallow or deep copy). It is required when default copying would cause incorrect behaviour (e.g., shared pointers or dynamic memory).
A destructor is a special method that is invoked when an object’s lifetime ends. Its job is to clean up—free memory, close files, release locks, or deregister resources. In languages like C++ it is deterministic; in garbage-collected languages the timing may vary.
A memory leak occurs when objects or resources (memory, file handles) are not properly released after they are no longer used. Over time this degrades system performance and may cause failures. Proper design of constructors and destructors (or finalisers) is essential to avoid leaks.
Constructor chaining is when one constructor calls another constructor in the same class (or base class) to reuse initialization logic. In languages like Java you use `this(...)` to call another constructor in the same class, or `super(...)` to call the base class constructor. In C++ the base class constructor is called before the derived class constructor body executes. This ensures that shared initialization code is executed only once, and simplifies object construction across class hierarchies.
A shallow copy duplicates the top-level object but shares references of nested or linked resources. This means that changes in one object’s nested resource affect the other. A deep copy duplicates both the object and all nested resources, so each object has its own independent state. Deep copy is needed when objects own resources (like dynamically allocated memory) that should not be shared. Many interviewers expect you to mention copy constructors, clone methods, and manage memory safely.
In Java, there is no explicit destructor mechanism like in C++, but you can override `finalize()` or implement `AutoCloseable` and use try-with-resources for resource cleanup. However, `finalize()` is deprecated because its execution timing is unpredictable, it can delay resource release, and may introduce performance overhead. Therefore good design uses explicit close methods and avoids relying on GC for critical resource cleanup.
An object’s lifetime begins when it is created (constructor runs), then it exists in a usable state, and ends when it is destroyed or collected. During this time its state is consistent. Understanding object lifetime helps manage memory and resources correctly.
In garbage-collected languages (like Java, C#) objects are destroyed when the runtime’s GC deems them unreachable. This is non-deterministic compared to languages like C++ where destructors run immediately when scope ends or when delete is called. Understanding this helps interview candidates discuss resource management trade-offs.
In C++ the Rule of Three states that if you define a custom destructor, copy constructor or copy assignment operator then you should probably define all three to manage resources safely. With move semantics (C++11) this extends to the Rule of Five (add move constructor and move assignment). Following these rules prevents shallow copies, double deletion, and resource leaks. Interviewers who ask this expect you to recognise how constructors, destructors and assignment interplay in safe class design.