Lesson 1

The following will be discussed:

1. How constructors and destructors provide management of class-defined object
2. How to use a constructor for initialization
3. About the use of default constructors
4. How to use constructor initializers
5. How constructors can perform automatic conversions

At the end of the module, you will be given the opportunity to take a quiz covering these topics.

In C++ programming, constructors and destructors play a crucial role in the management of class-defined objects. Their primary function is to control the initialization and destruction process of these objects, ensuring that resources are allocated and released correctly.

1. Constructors:
   • Constructors are special member functions of a class that are invoked when an object of that class is created.
   • They are primarily used to initialize the object's properties. Constructors can set default values, allocate memory, or perform any startup procedure necessary for the class to operate correctly.
   • C++ supports different types of constructors, including default constructors, parameterized constructors, copy constructors, and move constructors. Each serves a specific purpose in initializing an object in different scenarios.
   • Constructors do not have a return type, not even void, and they have the same name as the class.
2. Destructors:
   • Destructors are special member functions that are invoked when an object of the class is destroyed.
   • Their primary purpose is to free the resources that the object may have acquired during its lifetime. This is crucial in the context of dynamic memory allocation, file handling, and releasing network resources.
   • A destructor is defined with a tilde (~) followed by the class name and, like constructors, does not return a value.
   • In C++, destructors are particularly important for classes that deal with dynamic memory allocation or resource management, adhering to the RAII (Resource Acquisition Is Initialization) principle. This principle ensures that resources are tied to the lifespan of objects, thus preventing resource leaks and ensuring more robust memory management.

By effectively managing the life cycle of objects, constructors and destructors help maintain a clean and efficient runtime environment. They automate the processes of initialization and cleanup, reducing the likelihood of errors like memory leaks and dangling pointers, and contribute significantly to the overall robustness and reliability of C++ applications.

The process of creating and deleting objects in C++ can be described by the following two operations.
Every time an instance of a class is created the constructor method is called. The constructor has the same name as the class and it does not have a return type.
The destructor has the same name as the class and has a '~' in front of it.

It is very common for some part of an object to require initialization before it can be used. For example, the stack class.
Before the stack can be used, tos had to be set to zero. This was performed by using the function init( ). Because the requirement for initialization is so common, C++ allows objects to initialize themselves when they are created. This automatic initialization is performed through the use of a constructor function. A constructor is a special function that is a member of a class and has the same name as that class. For example, here is how the stack class looks when converted to use a constructor for initialization:

// This creates the class stack.
class stack {
int stck[SIZE];
int tos;
public:
stack(); // constructor
void push(int i);
int pop();
};

// stack's constructor
stack::stack()
{
tos = 0;
cout << "Stack Initialized\n";
}