Execution of Constructors and Destructors

When programming in C++, constructors and destructors are essential to managing object creation and destruction. Understanding when these functions are executed is crucial for ensuring that your code functions properly and efficiently. In this post, we'll explore the precise timing of when constructors and destructors are executed for both local and global objects.

Local objects are those that are declared within a function or block. The constructor for a local object is executed when the object's declaration statement is encountered. For example:

void myFunction() {
   MyClass obj; // constructor called when this line is executed
   // do something with obj
} // destructor called when function returns and obj goes out of scope

The destructor for a local object is executed when the object goes out of scope, which in this case is when the function returns.

Global objects, on the other hand, are those that are declared outside of any function or block. The constructor for a global object is executed before the 'main()' function begins execution, in the order in which they are declared within the same file. For example:

// MyClass.h
class MyClass {
public:
   MyClass() { std::cout << "Constructor called" << std::endl; }
   ~MyClass() { std::cout << "Destructor called" << std::endl; }
};

// main.cpp
#include "MyClass.h"

MyClass obj1; // first global object, constructor called first
MyClass obj2; // second global object, constructor called second

int main() {
   // do something with obj1 and obj2
} // destructors called after main() function terminates, in reverse order

Global destructors are executed after the 'main()' function has terminated, in reverse order of their declaration within the same file. However, it's important to note that the order of execution of global constructors across multiple files is not defined.

Summary

constructors and destructors play a vital role in C++ programming, and understanding when they are executed is essential for writing efficient and effective code. By following best practices and carefully managing object creation and destruction, you can ensure that your code runs smoothly and reliably.