Destructor, Its Characteristics, and Default Copy Constructor

1. Destructor (Definition)

A destructor is a special member function of a class that destructs or deletes an object and performs cleanup operations (such as releasing memory) when the object is no longer needed.

When is a Destructor Called?

A destructor is called automatically when:

• The function ends (object goes out of scope of a function)
• The program ends
• A block containing local variables ends
• The delete operator is called on a dynamically allocated object

2. Characteristics of Destructor

3. Example of Destructor

#include <iostream>
#include <string.h>
using namespace std;

class String {
private:
    char *s;
    int size;

public:
    String(char *c) {           // Constructor
        size = strlen(c);
        s = new char[size + 1];
        strcpy(s, c);
        cout << "Constructor called. String: " << s << endl;
    }

    ~String() {                 // Destructor
        delete[] s;             // Free dynamically allocated memory
        cout << "Destructor called. Memory freed." << endl;
    }
};

int main() {
    String str("Hello");        // Constructor is called here
    // Destructor is called automatically when str goes out of scope
    return 0;
}

Output:

Constructor called. String: Hello
Destructor called. Memory freed.

4. Default Copy Constructor

Definition

A copy constructor is a special constructor that creates a new object as a copy of an existing object of the same class. When the programmer does not define a copy constructor explicitly, C++ automatically provides a default copy constructor.

The default copy constructor performs a member-wise (shallow) copy of all data members from one object to another.

Syntax

ClassName (const ClassName &old_object);

How the Default Copy Constructor Works

• It copies each data member of the source object directly into the corresponding data member of the new object.
• This is called a shallow copy because it copies values as-is, including pointer addresses (not the data pointed to).

When is the Copy Constructor Invoked?

1. When an object is initialized with another object of the same class
2. When an object is passed by value to a function
3. When an object is returned by value from a function

5. Example: Default Copy Constructor

#include <iostream>
using namespace std;

class Student {
private:
    int rollNo;
    float marks;

public:
    // Parameterized Constructor
    Student(int r, float m) {
        rollNo = r;
        marks = m;
    }

    void display() {
        cout << "Roll No: " << rollNo
             << ", Marks: " << marks << endl;
    }
};

int main() {
    Student s1(101, 85.5);      // Original object created using constructor

    Student s2 = s1;            // Default copy constructor is called here
                                // s2 is a copy of s1

    cout << "Object s1 -> ";
    s1.display();

    cout << "Object s2 -> ";
    s2.display();

    return 0;
}

Output:

Object s1 -> Roll No: 101, Marks: 85.5
Object s2 -> Roll No: 101, Marks: 85.5

Explanation

6. Limitation of Default Copy Constructor (Shallow Copy Problem)

When a class contains pointer members, the default copy constructor copies only the address of the pointer, not the actual data. This means both objects point to the same memory location, which can cause problems (double deletion, data corruption). In such cases, a user-defined copy constructor performing a deep copy is required.

s1.ptr -----> [Memory Block]
s2.ptr -----> [Same Memory Block]   <-- Problem!

Summary Table

Object and Benefits of Object Oriented Programming Language

Definition of Object

An object is a basic run-time entity in an object-oriented system. Objects are variables (instances) of a user-defined data type called a class. They contain both data and code to manipulate that data.

"Objects are the basic run-time entities in an object-oriented system... In fact, objects are variables of the type class."

Key characteristics of an object:

• Objects take up space in memory and have an associated address (like structures or unions in C).
• When a program is executed, objects interact by sending messages to one another.
• Program objects are chosen such that they match closely with real-world objects.

Example:

class person {
    char name[20];
    int age;
public:
    void getdetails() { }
};

int main() {
    person p1;   // p1 is an object of class person
}

Here, p1 is an object of class person that holds its own copy of name and age.

Benefits of Object Oriented Programming (OOP)

Summary

In short, OOP overcomes the major drawbacks of procedural programming by providing security through data hiding, real-world modeling, easy extensibility, and code reusability, making it the preferred approach for developing large-scale, maintainable software systems.