Section A — 1 Mark Questions
1. What is a constructor with default arguments? [1 Mark]
Answer: A constructor that assigns default values to its parameters, allowing objects to be created with fewer arguments than the total number of parameters.
2. Can a constructor be overloaded? [1 Mark]
Answer: Yes, a constructor can be overloaded by having multiple constructors with different parameter lists.
3. When is a destructor called? [1 Mark]
Answer: A destructor is called automatically when an object goes out of scope or is explicitly deleted.
4. How is dynamic initialization of objects performed? [1 Mark]
Answer: It is performed by allocating memory for an object at runtime using the new operator.
5. What symbol precedes a destructor name? [1 Mark]
Answer: The tilde symbol (~).
6. Can a destructor accept arguments? [1 Mark]
Answer: No, a destructor cannot accept any arguments.
7. What is the main purpose of dynamic initialization? [1 Mark]
Answer: To initialize objects using values that are determined at runtime rather than at compile time.
8. What is the return type of a constructor? [1 Mark]
Answer: Constructors have no return type, not even void.
9. How many destructors can a class have? [1 Mark]
Answer: A class can have only one destructor.
10. Does a default constructor take arguments? [1 Mark]
Answer: A default constructor takes no arguments, or all its parameters have default values.
11. What operator is used to deallocate memory for an object created dynamically? [1 Mark]
Answer: The delete operator.
12. What happens if no destructor is defined in a class? [1 Mark]
Answer: The compiler generates a default destructor.
13. Can dynamic initialization be used with constructors having default arguments? [1 Mark]
Answer: Yes, it can.
14. Does the order of destruction matter? [1 Mark]
Answer: Yes, objects are destroyed in the reverse order of their construction.
15. What is the scope of a constructor? [1 Mark]
Answer: It is generally public to allow object creation.
16. Can destructors be virtual? [1 Mark]
Answer: Yes, destructors can be virtual to ensure proper cleanup in inheritance hierarchies.
17. Define an object's lifecycle. [1 Mark]
Answer: The time from the object's construction until its destruction.
18. Are destructors inherited? [1 Mark]
Answer: No, destructors are not inherited by derived classes.
19. Can dynamic objects be created on the stack? [1 Mark]
Answer: No, dynamic objects are created on the heap.
20. What is the primary role of a destructor? [1 Mark]
Answer: To release resources or memory occupied by the object.
Section B — 2/3 Mark Questions
1. Explain the concept of dynamic initialization of objects with an example. [3 Marks]
Answer: Dynamic initialization allows initializing objects during runtime using data that is not available at compile time. This is achieved using the 'new' operator. For example, 'Point* p = new Point(x, y);' initializes the object p in the heap memory at runtime.
2. Compare constructors and destructors. [2 Marks]
Answer: Constructors are used to initialize objects when they are created and can be overloaded. Destructors are used to clean up resources when an object is destroyed and cannot be overloaded.
3. Why are destructors necessary in classes that manage dynamic memory? [3 Marks]
Answer: When an object allocates memory on the heap (e.g., using 'new'), that memory is not automatically reclaimed when the object goes out of scope. The destructor is necessary to explicitly 'delete' that memory to prevent memory leaks.
4. State the rules for defining a destructor. [2 Marks]
Answer: A destructor must have the same name as the class preceded by a tilde (~), must have no return type, and must not accept any parameters.
5. How do default arguments in a constructor improve code flexibility? [2 Marks]
Answer: They allow the user to create objects with varying levels of detail. If the user provides no arguments, the defaults are used; if specific arguments are provided, they override the defaults.
6. Describe the order of destruction for objects. [2 Marks]
Answer: Objects are destroyed in the reverse order of their construction. If global objects exist, they are destroyed after the main function terminates.
7. Can a constructor be private? Explain. [3 Marks]
Answer: Yes, a constructor can be private. This is used in cases like the Singleton design pattern, where you want to restrict object creation to specific methods within the class or prevent creating instances from outside the class.
8. What is the difference between static and dynamic object initialization? [3 Marks]
Answer: Static initialization happens at compile time or when memory is allocated on the stack. Dynamic initialization happens at runtime when memory is allocated on the heap using the 'new' operator. Dynamic initialization provides more flexibility for resource allocation.
9. Why do we use virtual destructors in a base class? [2 Marks]
Answer: A virtual destructor ensures that the derived class's destructor is called when a base class pointer is used to delete a derived object, preventing partial destruction and memory leaks.
10. What happens if a constructor fails to allocate memory? [2 Marks]
Answer: If a constructor cannot complete its task (like memory allocation), it should throw an exception. The object's destructor will not be called because the object was never fully constructed.
Section C — 5 Mark Questions
1. Explain the role and mechanism of constructors with default arguments. [5 Marks]
Answer:
Introduction
Constructors with default arguments provide a way to supply default values to parameters if the caller does not provide specific values during object instantiation.
Mechanism
When a constructor is defined with default parameters (e.g., 'ClassName(int x = 10, int y = 20)'), the compiler fills in the missing arguments with these defaults. This reduces the need to write multiple overloaded constructors for simple variations.
Key Points
- It simplifies class interfaces by reducing the number of constructors required.
- It maintains backward compatibility if new parameters are added later.
- If only some parameters have default values, they must be the trailing ones in the parameter list.
- It is safer and more readable than having many overloaded constructors performing similar logic.
Example
If a class 'Rectangle' has a constructor 'Rectangle(int w = 5, int h = 10)', calling 'Rectangle r1;' initializes it with 5 and 10, while 'Rectangle r2(20);' initializes it with 20 and 10.
2. Discuss the importance and lifecycle of destructors in C++. [5 Marks]
Answer:
Introduction
A destructor is a special member function that is invoked automatically when an object of a class is destroyed.
Lifecycle
The lifecycle of an object starts at its construction. Once the execution scope (where the object was created) ends or the 'delete' operator is called, the destructor enters the lifecycle to perform cleanup.
Importance
- Resource Management: It is crucial for releasing non-memory resources like file handles, network connections, or database locks.
- Memory Cleanup: It deallocates memory previously allocated by the constructor using 'new'.
- Order of Destruction: Objects are destroyed in the reverse order of their creation, which ensures that dependencies between objects are handled correctly.
- Safety: It prevents resource leaks, which could otherwise lead to system crashes or performance degradation over time.
Without a properly defined destructor, resources held by an object may persist even after the object is gone, causing severe bugs in long-running programs.
3. Describe the process and advantages of dynamic initialization of objects. [5 Marks]
Answer:
Introduction
Dynamic initialization involves creating objects on the heap during runtime rather than on the stack during compile time. This is done using the 'new' keyword.
Process
The 'new' operator performs two tasks: it allocates enough memory to hold the object, and then it calls the appropriate constructor to initialize that memory. A pointer is returned to the memory address, which allows the programmer to track the object throughout the program.
Advantages
- Lifetime Control: The programmer decides exactly when the object is created and destroyed using 'new' and 'delete', rather than being constrained by scope.
- Large Data Handling: Heap memory is typically much larger than stack memory, allowing for large objects or large collections of objects.
- Conditional Creation: Objects can be created conditionally, saving memory if they are not needed in certain program execution paths.
- Polymorphism: It is essential when dealing with inheritance, as pointers allow accessing derived objects through base pointers.
It is important to remember that memory managed dynamically must be explicitly released to avoid memory leaks.
4. Compare and contrast default constructors, constructors with default arguments, and overloaded constructors. [5 Marks]
Answer:
Comparison Table
| Type | Characteristics |
|---|---|
| Default Constructor | Takes no arguments or parameters. |
| Constructor with Default Args | Allows missing arguments to be filled by pre-defined values. |
| Overloaded Constructor | Multiple constructors with unique parameter signatures. |
Detailed Explanation
A default constructor is required if you want to create arrays of objects or if you declare objects without immediate initialization. Constructors with default arguments offer a concise way to handle common initial values without bloating the class with multiple functions. Overloaded constructors provide complete control over initialization, as each version can perform distinct logic or handle entirely different data types. While default arguments can often replace simple overloads, overloads are superior when different initialization logic is required for different argument patterns, which default arguments cannot easily distinguish.
5. Explain how destructors are used in conjunction with the 'new' and 'delete' operators. [5 Marks]
Answer:
Introduction
In C++, managing resources manually involves the 'new' and 'delete' operators. The destructor acts as the safety net for this manual management.
The Mechanism
When 'new' is used, the heap allocates memory and the constructor initializes it. The destructor is specifically designed to work with the 'delete' operator. When 'delete' is called on a pointer to an object, the destructor is automatically triggered for that specific object before the memory is released back to the heap.
Scenario
- If a class has a pointer member that points to dynamically allocated memory, the destructor must contain a 'delete[]' or 'delete' call to clean up that specific memory.
- If the destructor is omitted in this context, the object is removed, but the memory it pointed to remains allocated, creating a 'memory leak'.
- Multiple instances of objects created with 'new' must be individually deleted, ensuring each calls its own destructor.
Conclusion
Following the pattern of 'new' to allocate and 'delete' to invoke the destructor is a fundamental practice in C++ for maintaining system stability and preventing memory exhaustion.