Unit 11: Constructors and Destructors in C++

Introduction to Constructors

A constructor is a special member function of a class that is automatically called when an object of that class is created. Its primary purpose is to initialize the object's data members and to perform any necessary setup tasks.

Definition: A constructor is a special member function of a class that is automatically invoked when an object of the class is instantiated. It shares the same name as the class and has no return type.

Key Characteristics of Constructors:

• Constructors always have the same name as the class they belong to.
• They do not have any return type, not even void.
• They are automatically invoked by the compiler when an object of the class is created.
• They can be overloaded, meaning a class can have multiple constructors with different parameter lists.
• They are primarily used for initializing an object's state.

Default Constructor: If you do not explicitly provide any constructor for your class, the C++ compiler automatically generates a public, no-argument constructor called the default constructor. This default constructor performs default initialization for data members.

Example: Default Constructor

class MyClass {public:  int data;  // Default Constructor  MyClass() {    data = 0;    // std::cout << "Default Constructor called!" << std::endl;  }};int main() {  MyClass obj1; // Calls the default constructor  // std::cout << "obj1.data: " << obj1.data << std::endl; // Output: 0  return 0;}

Parameterized Constructors

A parameterized constructor is a constructor that accepts one or more arguments. These arguments are used to initialize the object's data members with specific values provided at the time of object creation, offering more flexibility in initialization.

Definition: A parameterized constructor is a constructor that takes one or more arguments. It allows objects to be initialized with custom values when they are created, differentiating them from the default constructor.

When using a parameterized constructor, you can pass arguments to it in two ways: implicitly (shorthand notation) or explicitly (longhand notation).

Example: Parameterized Constructor

class Point {public:  int x, y;  // Parameterized Constructor  Point(int x1, int y1) {    x = x1;    y = y1;    // std::cout << "Parameterized Constructor called for (" << x << ", " << y << ")" << std::endl;  }};int main() {  // Implicit call:  Point p1(10, 20);  // Explicit call:  Point p2 = Point(30, 40);  // std::cout << "p1 coordinates: " << p1.x << ", " << p1.y << std::endl; // Output: 10, 20  return 0;}

Important Observation: If you define any parameterized constructor in your class, the compiler will not automatically generate a default constructor. If you still need a default constructor (one that takes no arguments), you must define it explicitly.

Copy Constructors

A copy constructor is a special type of constructor that creates a new object as a copy of an existing object of the same class. It takes a reference to an object of its own class as an argument.

Definition: A copy constructor is a member function that initializes an object by copying an existing object of the same class. Its typical signature is ClassName(const ClassName &obj).

The copy constructor is invoked in the following situations:

• When an object is initialized with another object of the same type during its creation (e.g., MyClass obj2 = obj1; or MyClass obj3(obj1);).
• When an object is passed by value to a function.
• When a function returns an object by value.

Example: Copy Constructor

class MyNumber {public:  int value;  // Constructor  MyNumber(int v = 0) : value(v) {    // std::cout << "Constructor called for value: " << value << std::endl;  }  // Copy Constructor  MyNumber(const MyNumber &source) {    value = source.value;    // std::cout << "Copy Constructor called for value: " << value << std::endl;  }};void funcByValue(MyNumber obj) {  // obj is a copy, copy constructor called}int main() {  MyNumber num1(10);        // Parameterized constructor  MyNumber num2 = num1;     // Copy constructor  MyNumber num3(num1);      // Copy constructor  funcByValue(num1);       // Copy constructor for the parameter  // std::cout << "num2 value: " << num2.value << std::endl; // Output: 10  return 0;}

Shallow Copy vs. Deep Copy:

By default, if you don't define a copy constructor, the C++ compiler provides a default copy constructor that performs a member-wise copy. This is known as a shallow copy. For classes containing only primitive data types or objects without dynamically allocated resources, a shallow copy works fine. However, if a class contains pointers or dynamically allocated memory, a shallow copy will only copy the pointer address, leading to both objects pointing to the same memory location. This can cause issues like double-free errors or one object modifying data unexpectedly for another.

To avoid these problems with dynamic memory, a deep copy is required. A deep copy involves creating new memory for the copied object's dynamic members and then copying the actual content from the source object's dynamic memory. This is where dynamic constructors become relevant, often working in tandem with custom copy constructors.

Dynamic Constructors

A dynamic constructor is a constructor that allocates memory dynamically for an object's data members during its creation. This is particularly useful when the size or nature of certain data members is not fixed at compile time and needs to be determined or allocated at runtime (on the heap).

Definition: A dynamic constructor is a constructor that uses dynamic memory allocation (e.g., employing the new operator) to create or initialize an object's data members on the heap.

Dynamic constructors are essential for classes that manage resources suchently, such as dynamic arrays, linked lists, or file handles. When dynamic memory is allocated, it is crucial to also implement a corresponding destructor to release that memory, and often a deep copy constructor to handle object copying correctly.

Example: Dynamic Constructor with Deep Copy Copy Constructor

class DynamicArray {private:  int *arr; // Pointer to dynamically allocated memory  int size;public:  // Dynamic Constructor  DynamicArray(int s) : size(s) {    arr = new int[size]; // Dynamically allocate memory for 'size' integers    // std::cout << "Dynamic Constructor called. Allocated " << size << " integers." << std::endl;    for (int i = 0; i < size; ++i) {      arr[i] = 0; // Initialize elements    }  }  // Copy Constructor for Deep Copy  DynamicArray(const DynamicArray &source) : size(source.size) {    arr = new int[size]; // Allocate new memory for the copy    // std::cout << "Deep Copy Constructor called. Allocated " << size << " integers." << std::endl;    for (int i = 0; i < size; ++i) {      arr[i] = source.arr[i]; // Copy contents from source to new memory    }  }  // Destructor (to deallocate dynamically allocated memory)  ~DynamicArray() {    delete[] arr; // Release the dynamically allocated array    arr = nullptr; // Prevent dangling pointer    // std::cout << "Destructor called. Deallocated memory." << std::endl;  }};int main() {  DynamicArray d1(5); // Calls dynamic constructor  // d1.arr now points to a block of 5 integers initialized to 0.  DynamicArray d2 = d1; // Calls deep copy constructor  // d2.arr now points to a separate block of 5 integers, copied from d1.  // When d1 and d2 go out of scope, their respective destructors will be called,  // correctly deallocating their unique memory blocks.  return 0;}

Multiple Constructors in a Class (Constructor Overloading)

A class can have more than one constructor, provided that each constructor has a unique signature (i.e., different number of parameters, different types of parameters, or different order of parameter types). This capability is known as constructor overloading.

Definition: Constructor overloading allows a class to have multiple constructors, each defined with a distinct parameter list. This provides flexibility in creating and initializing objects in various ways based on the arguments supplied.

The C++ compiler uses the number and types of arguments passed during object creation to determine which constructor to invoke. This is a form of polymorphism.

Example: Multiple Constructors

class Box {public:  double length, width, height;  // 1. Default constructor (no arguments)  Box() {    length = 0.0;    width = 0.0;    height = 0.0;    // std::cout << "Default Box created." << std::endl;  }  // 2. Parameterized constructor for a cube (one argument)  Box(double side) {    length = side;    width = side;    height = side;    // std::cout << "Cube Box created with side: " << side << std::endl;  }  // 3. Parameterized constructor for a rectangular box (three arguments)  Box(double l, double w, double h) {    length = l;    width = w;    height = h;    // std::cout << "Rectangular Box created with dimensions: " << l << ", " << w << ", " << h << std::endl;  }};int main() {  Box b1;         // Calls the default constructor  Box b2(10.0);   // Calls the constructor for a cube  Box b3(2.0, 3.0, 4.0); // Calls the constructor for a rectangular box  return 0;}

Destructors

A destructor is a special member function of a class that is automatically called when an object is destroyed or goes out of scope. Its primary purpose is to perform cleanup tasks, such as deallocating dynamically allocated memory or closing file handles, ensuring that resources are properly released before the object is removed from memory.

Definition: A destructor is a special member function prefixed with a tilde (~) that is automatically invoked when an object is destroyed. It takes no arguments and has no return type. Its main role is to free up resources acquired by the object.

Key Characteristics of Destructors:

• Destructors have the same name as the class, but prefixed with a tilde (~), for example, ~MyClass().
• They do not take any arguments and cannot be overloaded.
• They do not have a return type, not even void.
• A class can have only one destructor.
• Destructors are automatically invoked when an object goes out of scope, when delete is called on a dynamically allocated object, or when the program terminates.
• Their main use is to deallocate memory, close files, or release any other system resources that the object might have acquired during its lifetime.

Example: Destructor

#include <iostream>class FileHandler {private:  // Assume this represents a file resource  bool isOpen;public:  // Constructor  FileHandler() {    isOpen = true;    // std::cout << "File opened (resource acquired)." << std::endl;  }  // Destructor  ~FileHandler() {    if (isOpen) {      // std::cout << "File closed (resource released)." << std::endl;      isOpen = false;    }  }};void useFile() {  FileHandler myFile; // Constructor called when myFile is created  // ... perform file operations ...} // Destructor for myFile is called automatically when it goes out of scopeint main() {  std::cout << "Entering useFile() scope." << std::endl;  useFile(); // myFile object is created and destroyed within this function call  std::cout << "Exited useFile() scope." << std::endl;  FileHandler* heapFile = new FileHandler(); // Constructor called for heap object  std::cout << "Heap object created." << std::endl;  delete heapFile; // Explicitly call destructor for heap object  std::cout << "Heap object deleted." << std::endl;  return 0;}