Discuss the role of constructors and destructors in C++. How are they used to initialize and clean up objects?

Constructors and destructors are essential elements in C++ classes that play a crucial role in object initialization and cleanup. Constructors are special member functions that are invoked when an object of a class is created, while destructors are invoked when the object is destroyed. Let's explore the role of constructors and destructors in C++, their usage for object initialization and cleanup, and their significance in class design.

1. Constructors:
Constructors are member functions with the same name as the class, and they are responsible for initializing the newly created objects of that class. Constructors are called automatically when an object is created and ensure that the object is properly initialized before it can be used. They initialize the data members of the class and perform any necessary setup operations.

Types of Constructors:

* Default Constructor: It is a constructor that can be called without any arguments. It is used when an object is created without explicitly providing any initialization values. If a class does not have a user-defined constructor, the compiler provides a default constructor.
* Parameterized Constructor: It is a constructor that takes one or more parameters, allowing the caller to provide initialization values for the object's data members.
* Copy Constructor: It is a constructor that creates a new object by initializing it with an existing object of the same class. It is invoked when a new object is created as a copy of an existing object.

Here's an example that demonstrates the usage of constructors:

```
cpp`class Person {
public:
string name;
int age;

// Default Constructor
Person() {
cout << "Default constructor called." << endl;
name = "";
age = 0;
}

// Parameterized Constructor
Person(string n, int a) {
cout << "Parameterized constructor called." << endl;
name = n;
age = a;
}

// Copy Constructor
Person(const Person& other) {
cout << "Copy constructor called." << endl;
name = other.name;
age = other.age;
}
};

int main() {
Person person1; // Default constructor called

Person person2("Alice", 25); // Parameterized constructor called

Person person3 = person2; // Copy constructor called

return 0;
}`
```
In this example, the `Person` class defines a default constructor, a parameterized constructor, and a copy constructor. The constructors initialize the `name` and `age` data members of the `Person` objects.

2. Destructors:
Destructors are special member functions with the same name as the class, preceded by a tilde (~). They are used to perform cleanup operations and deallocate resources held by an object when it goes out of scope or is explicitly destroyed. Destructors are called automatically when an object is destroyed, ensuring proper cleanup.

The destructor is particularly useful for releasing dynamically allocated memory, closing file handles, freeing system resources, or performing any other necessary cleanup operations.

Here's an example that demonstrates the usage of a destructor:

```
cpp`class Resource {
public:
Resource() {
cout << "Resource acquired." << endl;
}

~Resource() {
cout << "Resource released." << endl;
}
};

int main() {
{
Resource res; // Resource acquired
} // Resource released

return 0;
}`
```
In this example, the `Resource` class acquires a resource in the constructor and releases it in the destructor. When the `res` object goes out of scope, the destructor is automatically called, releasing the resource.

Benefits of Constructors and Destructors:

* Object Initialization: Constructors ensure that objects are properly initialized, setting the initial state of