C++ में कंस्ट्रक्टर कब कॉल होते हैं?

C++ में कंस्ट्रक्टर ऑब्जेक्ट के स्टोरेज ड्यूरेशन और लिंकेज के आधार पर अलग-अलग समय पर कॉल होते हैं। चार मुख्य श्रेणियां हैं: ग्लोबल, लोकल, स्टेटिक लोकल, और डायनामिक।

1. ग्लोबल ऑब्जेक्ट (Global Object)

कब: main() में प्रवेश करने से पहले

#include <iostream>
using namespace std;

class MyClass {
public:
    MyClass() { cout << "Global Constructor\n"; }
    ~MyClass() { cout << "Global Destructor\n"; }
};

MyClass globalObj;  // ग्लोबल ऑब्जेक्ट

int main() {
    cout << "Inside main\n";
    return 0;
}

आउटपुट

Global Constructor
Inside main
Global Destructor

2. लोकल ऑब्जेक्ट (Local/Automatic Object)

कब: जब एक्जीक्यूशन ऑब्जेक्ट डिक्लेरेशन पॉइंट तक पहुंचता है

#include <iostream>
using namespace std;

class MyClass {
public:
    MyClass() { cout << "Local Constructor\n"; }
    ~MyClass() { cout << "Local Destructor\n"; }
};

void func() {
    cout << "func() start\n";
    MyClass obj;  // यहां कंस्ट्रक्टर कॉल होता है
    cout << "After construction\n";
}  // यहां डिस्ट्रक्टर कॉल होता है

int main() {
    cout << "main() start\n";
    func();
    cout << "Back in main\n";
    return 0;
}

आउटपुट

main() start
func() start
Local Constructor
After construction
Local Destructor
Back in main

3. स्टेटिक लोकल ऑब्जेक्ट (Static Local Object)

कब: पहली बार जब एक्जीक्यूशन डिक्लेरेशन तक पहुंचता है। बाद के कॉल्स पर कंस्ट्रक्टर नहीं कॉल होता।

#include <iostream>
using namespace std;

class MyClass {
public:
    MyClass() { cout << "Static Local Constructor\n"; }
    ~MyClass() { cout << "Static Local Destructor\n"; }
};

void func() {
    static MyClass obj;  // केवल पहली बार कंस्ट्रक्ट होता है
    cout << "func() called\n";
}

int main() {
    cout << "main() start\n";
    func();  // कंस्ट्रक्टर कॉल होगा
    cout << "After first call\n";
    func();  // कंस्ट्रक्टर NOT कॉल होगा
    cout << "After second call\n";
    return 0;
}  // प्रोग्राम एंड पर डिस्ट्रक्टर कॉल होगा

आउटपुट

main() start
Static Local Constructor
func() called
After first call
func() called
After second call
Static Local Destructor

4. डायनामिक ऑब्जेक्ट (Dynamic Object - new)

कब: जब new एक्सप्रेशन एक्जीक्यूट होता है

#include <iostream>
#include <memory>
using namespace std;

class MyClass {
public:
    MyClass() { cout << "Dynamic Constructor\n"; }
    ~MyClass() { cout << "Dynamic Destructor\n"; }
};

int main() {
    cout << "main() start\n";
    MyClass *ptr = new MyClass();  // यहां कंस्ट्रक्टर
    cout << "After new\n";
    delete ptr;  // यहां डिस्ट्रक्टर
    cout << "After delete\n";
    
    // स्मार्ट पॉइंटर (RAII)
    {
        unique_ptr<MyClass> smart = make_unique<MyClass>();
        cout << "Inside smart pointer scope\n";
    }  // यहां ऑटोमैटिक डिलीट
    cout << "After smart pointer scope\n";
    
    return 0;
}

आउटपुट

main() start
Dynamic Constructor
After new
Dynamic Destructor
After delete
Dynamic Constructor
Inside smart pointer scope
Dynamic Destructor
After smart pointer scope

सारांश तालिका

महत्वपूर्ण गारंटीज

• ग्लोबल ऑब्जेक्ट्स: ट्रांसलेशन यूनिट में डिक्लेरेशन ऑर्डर में कंस्ट्रक्ट, रिवर्स ऑर्डर में डिस्ट्रक्ट
• अलग ट्रांसलेशन यूनिट्स में ग्लोबल्स: ऑर्डर अनस्पेसिफाइड (Static Initialization Order Fiasco)
• लोकल स्टेटिक्स: थ्रेड-सेफ इनिशियलाइजेशन (C++11 से)
• मेंबर्स: डिक्लेरेशन ऑर्डर में कंस्ट्रक्ट (इनिशियलाइजर लिस्ट ऑर्डर नहीं!)