Constructors and Destructors in c++

                                 CONSTRUCTORS

Constructors in C++ are special member functions of a class that are automatically called when an object of that class is created. They are used to initialize the object's data members and set up any necessary resources. Constructors have the same name as the class and do not have a return type, not even `void`.

Types of Constructors in c++

 1. Default Constructor
   - A constructor that takes no arguments.
   - If you don’t define any constructor, the compiler provides a default constructor.


  Example:
  
  class MyClass {
     public:
         MyClass() {
             std::cout << "Default Constructor Called!" << std::endl;
         }
     };

     int main() {
         MyClass obj; // Default constructor is called
         return 0;
     }

 2. Parameterized Constructor
   ->A constructor that takes one or more arguments.
   ->Used to initialize objects with specific values.

  Example:
     
    class MyClass {
     public:
         int x;
         MyClass(int value) {
             x = value;
             std::cout << "Parameterized Constructor Called! x = " << x << std::endl;
         }
     };

     int main() {
         MyClass obj(10); // Parameterized constructor is called
         return 0;
     }

 3.Copy Constructor
   - A constructor that initializes an object using another object of the same class.
   - It is used to create a copy of an existing object.

 Example:

class MyClass {
     public:
         int x;
         MyClass(int value) {
             x = value;
         }
         // Copy Constructor
         MyClass(const MyClass &obj) {
             x = obj.x;
             std::cout << "Copy Constructor Called! x = " << x << std::endl;
         }
     };

     int main() {
         MyClass obj1(10); // Parameterized constructor
         MyClass obj2 = obj1; // Copy constructor
         return 0;
     }

 4.Constructor Overloading
   ->A class can have multiple constructors with different parameter lists.
   -> The appropriate constructor is called based on the arguments provided.


  Example:
   class MyClass {
     public:
         int x, y;
         MyClass() { // Default constructor
             x = 0;
             y = 0;
         }
         MyClass(int a) { // Parameterized constructor with one argument
             x = a;
             y = 0;
         }
         MyClass(int a, int b) { // Parameterized constructor with two arguments
             x = a;
             y = b;
         }
     };

     int main() {
         MyClass obj1; // Default constructor
         MyClass obj2(10); // Parameterized constructor with one argument
         MyClass obj3(10, 20); // Parameterized constructor with two arguments
         return 0;
     }

Key Points About Constructors
1. Name: The constructor must have the same name as the class.
2. No Return Type: Constructors do not have a return type, not even `void`.
3. Automatic Invocation: Constructors are automatically called when an object is created.
4. Overloading: You can have multiple constructors in a class (constructor overloading).
5. Default Constructor: If no constructor is defined, the compiler provides a default constructor.   

  However, if you define any constructor (e.g., a parameterized constructor), the compiler will not provide a default constructor unless you explicitly define one.

Example:Full Program 
#include <iostream>
using namespace std;

class Rectangle {
private:
    int length, width;

public:
    // Default Constructor
    Rectangle() {
        length = 0;
        width = 0;
        cout << "Default Constructor Called!" << endl;
    }

    // Parameterized Constructor
    Rectangle(int l, int w) {
        length = l;
        width = w;
        cout << "Parameterized Constructor Called!" << endl;
    }

    // Copy Constructor
    Rectangle(const Rectangle &obj) {
        length = obj.length;
        width = obj.width;
        cout << "Copy Constructor Called!" << endl;
    }

    // Function to calculate area
    int area() {
        return length * width;
    }
};

int main() {
    Rectangle rect1; // Default constructor
    Rectangle rect2(5, 10); // Parameterized constructor
    Rectangle rect3 = rect2; // Copy constructor

    cout << "Area of rect1: " << rect1.area() << endl;
    cout << "Area of rect2: " << rect2.area() << endl;
    cout << "Area of rect3: " << rect3.area() << endl;

    return 0;
}

Best Practices
1. Always initialize all data members in the constructor to avoid undefined behavior.
2. Use constructor overloading to provide flexibility in object initialization.
3. Use the `explicit` keyword for single-argument constructors to avoid implicit conversions.



                                 DESTRUCTORS



A destructor in C++ is a special member function of a class that is automatically called when an object goes out of scope or is explicitly deleted. It is used to release resources (e.g., memory, file handles, network connections) that the object may have acquired during its lifetime. The destructor has the same name as the class but is prefixed with a tilde (`~').

Key Features of Destructors
1. Name: The destructor has the same name as the class, prefixed with a `~`.
2. No Parameters: Destructors cannot take any parameters.
3. No Return Type: Destructors do not have a return type, not even `void`.
4. Automatic Invocation: Destructors are automatically called when:
   - An object goes out of scope.
   - An object is explicitly deleted using the `delete` keyword.
   - The program terminates.
5. Cannot Be Overloaded: A class can have only one destructor.

Syntax of a Destructor:
class ClassName {
public:
    ~ClassName() {
        // Cleanup code
    }
};


When to Use a Destructor
->To release dynamically allocated memory (e.g., using `new`).
->To close files or database connections.
->To release any other system resources (e.g., network sockets).

Example: Basic Destructor
#include <iostream>
using namespace std;
class MyClass {
public:
    MyClass() {
        cout << "Constructor Called!" << endl;
    }

    ~MyClass() {
        cout << "Destructor Called!" << endl;
    }
};
int main() {
    MyClass obj; // Constructor is called
    cout << "Inside main function" << endl;
    return 0;
    // Destructor is called when obj goes out of scope
}

Output:
Constructor Called!
Inside main function
Destructor Called!

Destructor with Dynamic Memory Allocation:
    Destructors are particularly useful when dealing with dynamic memory allocation. If an object allocates memory using `new`, the destructor should release it using `delete`.

Example:
#include <iostream>
using namespace std;

class Array {
private:
    int* arr;
    int size;

public:
    // Constructor
    Array(int s) {
        size = s;
        arr = new int[size]; // Allocate memory
        cout << "Constructor Called! Memory allocated." << endl;
    }

    // Destructor
    ~Array() {
        delete[] arr; // Release memory
        cout << "Destructor Called! Memory deallocated." << endl;
    }

    // Function to display array
    void display() {
        for (int i = 0; i < size; i++) {
            cout << arr[i] << " ";
        }
        cout << endl;
    }
};

int main() {
    Array obj(5); // Constructor is called
    cout << "Array object created." << endl;
    return 0;
    // Destructor is called when obj goes out of scope
}

Output:
Constructor Called! Memory allocated.
Array object created.
Destructor Called! Memory deallocated


Key Points About Destructors:
1. Automatic Cleanup: Destructors ensure that resources are released automatically, preventing memory leaks.
2. Order of Destruction: Destructors are called in the reverse order of object creation.
3. No Overloading: A class can have only one destructor.
4. Implicit Destructor: If you don’t define a destructor, the compiler provides a default destructor. However, it does not handle dynamic memory or other resources.

Example: Multiple Objects and Destructor Order
#include <iostream>
using namespace std;

class MyClass {
public:
    int id;
    MyClass(int i) {
        id = i;
        cout << "Constructor Called for Object " << id << endl;
    }
    ~MyClass() {
        cout << "Destructor Called for Object " << id << endl;
    }
};

int main() {
    MyClass obj1(1);
    MyClass obj2(2);
    cout << "Inside main function" << endl;
    return 0;
    // Destructors are called in reverse order
}

Output
Constructor Called for Object 1
Constructor Called for Object 2
Inside main function
Destructor Called for Object 2
Destructor Called for Object 1

Destructor in Inheritance
   When dealing with inheritance, the destructor of the derived class is called first, followed by the destructor of the base class.

Example:
#include <iostream>
using namespace std;

class Base {
public:
    Base() {
        cout << "Base Constructor Called!" << endl;
    }
    ~Base() {
        cout << "Base Destructor Called!" << endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        cout << "Derived Constructor Called!" << endl;
    }
    ~Derived() {
        cout << "Derived Destructor Called!" << endl;
    }
};

int main() {
    Derived obj;
    cout << "Inside main function" << endl;
    return 0;
}
```

---

Output
Base Constructor Called!
Derived Constructor Called!
Inside main function
Derived Destructor Called!
Base Destructor Called!
```

---

Best Practices
1. Always define a destructor if your class manages resources (e.g., dynamic memory, file handles).
2. Use `delete[]` for arrays and `delete` for single objects in the destructor.
3. Avoid throwing exceptions in destructors, as it can lead to undefined behavior.



                     

                                                  Created by
                                 Name:H.Jeeva & S.Akashkumar
                                  Year:Ist bsc.Computer Science

Comments

Post a Comment

Popular posts from this blog

ETHICAL HACKING - WHITE HAT HACKER

                                                             ETHICAL HACKING -  WHITE HAT TECHNIQUES A white hat hacker, also known as an ethical hacker, is a cybersecurity professional who uses their skills and knowledge in hacking to identify vulnerabilities and weaknesses in computer systems, networks, or applications. White hat hackers have permission from the organization to conduct security testing, and they work within the boundaries of legal and ethical frameworks. Their primary goal is to help organizations improve their security by discovering and reporting these vulnerabilities. Ethical hackers use various tools, techniques, and methodologies to simulate real-world cyberattacks and assess the target system's security posture. They often collaborate with the organization's IT and security teams to remediate the identifi...
Read more

Radio Waves

Image
  Introduction of Radio Waves Radio waves are a type of electromagnetic radiation with wavelengths longer than infrared light. They have frequencies ranging from about 3 Hz to 300 GHz and are widely used in communication systems, including radio broadcasting, television signals, mobile phones, satellite transmissions, and Wi-Fi networks . Properties of Radio Waves: Long Wavelengths – They range from millimetres to hundreds of kilometres in length. Low Energy – Compared to other electromagnetic waves like X-rays or ultraviolet rays, radio waves have lower energy. Ability to Travel Long Distances – Radio waves can propagate over large distances, making them ideal for communication. Reflection, Refraction, and Diffraction – They can bounce off surfaces, bend around obstacles, and spread out after passing through narrow openings. Uses of Radio Waves: Communication: AM/FM radio, television, mobile phones, and walkie-tal...
Read more

Semantic Technology

Image
Semantic Technology Semantic technology uses formal semantics to help AI systems understand language and process information the way humans do. Thus, they are able to store, manage and retrieve information based on meaning and logical relationships. Various businesses are already using semantic technology and semantic graph databases such as Ontotext's GraphDB to manage their content, repurpose and reuse information, cut costs and gain new revenue streams. Semantic Technology uses formal semantics to give meaning to the disparate data that surrounds us. Together with  Linked Data  technology, it builds relationships between data in various formats and sources, from one string to another, helping create context. Interlinked in this way, these pieces of raw data form a giant web of data or a  knowledge graph , which connects a vast amount of descriptions of entities and concepts of general importance. Semantic Technology defines and links data on the Web (or within an enter...
Read more