CBSE Class 12 Computer Science Chapter 4: Constructor & Destructor NCERT Solutions

A constructor function in C++ possesses several key characteristics:

1. No Return Type: A constructor does not have any return type, not even `void`.
2. Same Name as Class: The name of the constructor function must be identical to the name of the class it belongs to.
3. Automatic Invocation: A constructor is automatically called by the system when an object of the class is created.
4. Default Invocation: If a programmer does not explicitly define any constructor within a class, the compiler implicitly provides a default constructor, which is then invoked upon object creation.

A copy constructor is a special type of overloaded constructor within a class. Its primary role is to create a new object by initializing it with the values of an existing object of the same class. The parameter passed to a copy constructor is typically a reference to an object of the same class.

Here is a C++ example illustrating a copy constructor:

class Point {
    int x;
public:
    // Default constructor
    Point() {
        x = 0;
    }

    // Parameterized constructor (optional, for illustration)
    Point(int val) {
        x = val;
    }

    // Copy constructor
    Point(Point &p) { // Takes a reference to an object of the same class
        x = p.x; // Initializes the new object's data member with the existing object's data member
    }

    void display() {
        // cout << "X value: " << x << endl;
    }
};

int main() {
    Point p1; // Default constructor is called, p1.x is initialized to 0
    Point p2(p1); // Copy constructor is called: p2 is created as a copy of p1
    // Alternatively, the following also calls the copy constructor:
    // Point p3 = p1; // Copy constructor is called: p3 is initialized from p1

    // p1.display(); // Output would show x = 0
    // p2.display(); // Output would show x = 0
    return 0;
}

In this example, `Point(Point &p)` is the copy constructor. When `Point p2(p1);` or `Point p3 = p1;` is executed, this copy constructor is invoked, creating `p2` and `p3` as copies of `p1`.

1. Which OOP concept does Function 1 and Function 2 implement? Explain? Function 1 and Function 2 implement the OOP concept of Constructor Overloading, which is a form of Polymorphism (specifically, compile-time polymorphism). This is because multiple functions (in this case, constructors) with the same name (`Exam`) are defined within the same scope, but they have different parameter lists. Function 1 is a Default Constructor as it takes no arguments, initializing the object's members to default values. Function 2 is a Parameterized Constructor as it accepts arguments (`Rno` and `candname`) to initialize the object's members with specific values provided during object creation.
2. What is Function 3 called? When will it be invoked? Function 3, `~Exam()`, is called a Destructor. It is automatically invoked by the system when an object of the `Exam` class goes out of scope, or when the memory allocated for the object is deallocated (e.g., when a program terminates or when `delete` is called on a dynamically allocated object). The destructor is used to perform cleanup operations, such as releasing dynamically allocated memory.