8.2 Constructors and Destructors

Object lifecycle management is crucial in C++ programming. Constructors initialize new objects, setting initial values and allocating resources. They ensure objects start in a valid state and can be overloaded for flexibility.

Destructors clean up resources when objects are destroyed. They free memory, close connections, and release system resources. Understanding constructor and destructor invocation is key to preventing memory leaks and managing object lifetimes effectively.

Object Lifecycle Management

Purpose of class constructors

• Initialize new objects setting initial values for attributes and allocating necessary resources
• Automatically called when object created with same name as class and no return type specified
• Can be overloaded providing different initialization options (multiple parameters, default values)
• Default constructor provided if none explicitly defined
• Ensure objects start in valid, usable state

Implementation of parameterized constructors

• Accept parameters setting initial values for object attributes allowing flexible object creation
• Syntax: ClassName(parameter1, parameter2, ...) initializes attributes directly
• Use member initializer lists for efficient initialization: ClassName(int x) : attribute(x) {}
• Call other constructors using delegating constructors: ClassName() : ClassName(default_value) {}
• Implement multiple constructors handling various scenarios (different parameter combinations)

Role of destructors

• Clean up resources allocated by object when it goes out of scope or explicitly deleted
• Named with tilde (~) followed by class name, no parameters or return type
• Cannot be overloaded, executes in reverse order of construction for inheritance
• Free dynamically allocated memory (delete[] array)
• Close open files or database connections (file.close())
• Release system resources (mutex.unlock())

Invocation of constructors vs destructors

• Constructors:
  1. Invoked implicitly creating stack objects: ClassName obj;
  2. Called explicitly using dynamic allocation: ClassName* obj = new ClassName();
  3. Chained in derived classes ensuring proper base initialization
• Destructors:
  1. Called automatically for stack objects going out of scope
  2. Invoked manually for heap objects: delete obj;
  3. Execute implicitly when program terminates
• Proper invocation ensures complete object initialization, timely resource deallocation, and prevents memory leaks