अंतिम अद्यतन：2026-10-12

C++ static मेंबर और lifetime¶

लेखक के बारे में¶

WeChat सार्वजनिक अकाउंट:

wechat

अलग-अलग टाइप के साथ उपयोग करने पर, static कीवर्ड के अलग-अलग अर्थ होते हैं। हम static कीवर्ड का उपयोग कर सकते हैं:

static वेरिएबल: फ़ंक्शन में वेरिएबल, क्लास में वेरिएबल

static क्लास मेंबर: क्लास ऑब्जेक्ट और क्लास में फ़ंक्शन

अब static के इन उपयोगों को विस्तार से देखते हैं:

static वेरिएबल

फ़ंक्शन में static वेरिएबल

जब वेरिएबल static घोषित किया जाता है, तो space प्रोग्राम के lifetime के दौरान allocate होगा। भले फ़ंक्शन कितनी ही बार कॉल हो, static वेरिएबल का space केवल एक बार allocate होता है, पिछली कॉल की वेरिएबल वैल्यू अगली फ़ंक्शन कॉल में चली जाती है। यह C / C++ या किसी भी ऐसे एप्लिकेशन के लिए उपयोगी है जिसे फ़ंक्शन की पिछली स्थिति स्टोर करनी हो।

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

void demo() 
{ 
    // static variable 
    static int count = 0; 
    cout << count << " "; 

    // value is updated and 
    // will be carried to next 
    // function calls 
    count++; 
} 

int main() 
{ 
    for (int i=0; i<5; i++)  
        demo(); 
    return 0; 
}

आउटपुट:

0 1 2 3 4

आप ऊपर के प्रोग्राम में देख सकते हैं कि वेरिएबल count को static घोषित किया गया है। इसलिए, इसकी वैल्यू फ़ंक्शन कॉल के साथ आगे बढ़ती है। हर बार फ़ंक्शन कॉल पर, वेरिएबल count को initialize नहीं किया जाता।

क्लास में static वेरिएबल

static घोषित वेरिएबल केवल एक बार initialize होता है, क्योंकि उन्हें अलग static storage में जगह मिलती है, इसलिए क्लास में static वेरिएबल ऑब्जेक्ट द्वारा साझा किया जाता है। अलग-अलग ऑब्जेक्ट के लिए एक ही static वेरिएबल की कई copy नहीं हो सकतीं। इसी कारण से, static वेरिएबल को कंस्ट्रक्टर से initialize नहीं किया जा सकता।

#include<iostream> 
using namespace std; 

class Apple 
{ 
public: 
    static int i; 

    Apple() 
    { 
        // Do nothing 
    }; 
}; 

int main() 
{ 
Apple obj1; 
Apple obj2; 
obj1.i =2; 
obj2.i = 3; 

// prints value of i 
cout << obj1.i<<" "<<obj2.i; 
}

आप ऊपर के प्रोग्राम में देख सकते हैं कि हमने कई ऑब्जेक्ट के लिए static वेरिएबल i की कई copy बनाने की कोशिश की। लेकिन ऐसा नहीं हुआ। इसलिए, क्लास में static वेरिएबल को यूज़र द्वारा क्लास के बाहर क्लास के नाम और scope resolution ऑपरेटर से स्पष्ट रूप से initialize करना चाहिए, जैसा नीचे दिखाया गया है:

#include<iostream> 
using namespace std; 

class Apple 
{ 
public: 
    static int i; 

    Apple() 
    { 
        // Do nothing 
    }; 
}; 

int Apple::i = 1; 

int main() 
{ 
    Apple obj; 
    // prints value of i 
    cout << obj.i; 
}

आउटपुट:

static मेंबर

क्लास ऑब्जेक्ट का static होना

वेरिएबल की तरह, ऑब्जेक्ट भी static घोषित होने पर प्रोग्राम के lifetime तक scope रखते हैं।

निम्नलिखित प्रोग्राम पर विचार करें, जिसमें ऑब्जेक्ट non-static है।

#include<iostream> 
using namespace std; 

class Apple 
{ 
    int i; 
    public: 
        Apple() 
        { 
            i = 0; 
            cout << "Inside Constructor\n"; 
        } 
        ~Apple() 
        { 
            cout << "Inside Destructor\n"; 
        } 
}; 

int main() 
{ 
    int x = 0; 
    if (x==0) 
    { 
        Apple obj; 
    } 
    cout << "End of main\n"; 
}

आउटपुट:

Inside Constructor
Inside Destructor
End of main

ऊपर के प्रोग्राम में, ऑब्जेक्ट if block के अंदर non-static घोषित है। इसलिए, वेरिएबल का scope केवल if block के अंदर है। इसलिए, ऑब्जेक्ट बनते समय कंस्ट्रक्टर कॉल होता है, और if block का control निकलते समय डिस्ट्रक्टर कॉल होता है, क्योंकि ऑब्जेक्ट का scope केवल उस if block तक है जिसमें उसे घोषित किया गया। अगर हम ऑब्जेक्ट को static घोषित करें, तो देखें आउटपुट कैसे बदलता है।

#include<iostream> 
using namespace std; 

class Apple 
{ 
    int i; 
    public: 
        Apple() 
        { 
            i = 0; 
            cout << "Inside Constructor\n"; 
        } 
        ~Apple() 
        { 
            cout << "Inside Destructor\n"; 
        } 
}; 

int main() 
{ 
    int x = 0; 
    if (x==0) 
    { 
        static Apple obj; 
    } 
    cout << "End of main\n"; 
}

आउटपुट:

Inside Constructor
End of main
Inside Destructor

आप आउटपुट का बदलाव साफ़ देख सकते हैं। अब, main ख़त्म होने के बाद डिस्ट्रक्टर कॉल होता है। ऐसा इसलिए है क्योंकि static ऑब्जेक्ट का scope पूरे प्रोग्राम के lifetime तक फैला है।

क्लास में static फ़ंक्शन

क्लास के static डेटा मेंबर या static वेरिएबल की तरह, static मेंबर फ़ंक्शन भी क्लास के ऑब्जेक्ट पर निर्भर नहीं होता। हमें ऑब्जेक्ट और '.' से static मेंबर फ़ंक्शन कॉल करने की अनुमति है। लेकिन static मेंबर को क्लास के नाम और scope resolution ऑपरेटर से कॉल करने की सलाह दी जाती है।

static मेंबर फ़ंक्शन को केवल static डेटा मेंबर या दूसरे static मेंबर फ़ंक्शन एक्सेस करने की अनुमति है, वे क्लास के non-static डेटा मेंबर या मेंबर फ़ंक्शन एक्सेस नहीं कर सकते।

#include<iostream> 
using namespace std; 

class Apple 
{ 
    public: 
        // static member function 
        static void printMsg() 
        {
            cout<<"Welcome to Apple!"; 
        }
}; 

// main function 
int main() 
{ 
    // invoking a static member function 
    Apple::printMsg(); 
}

आउटपुट:

Welcome to Apple!

access scope सीमित करना static का access scope सीमित करने वाला काम भी है (anonymous namespace की तरह)। issue से:https://github.com/Light-City/CPlusPlusThings/issues/142

// source1.cpp
extern void sayHello();
const char* msg = "Hello World!\n";
int main()
{
    sayHello();
    return 0;
}

// source2.cpp
#include <cstdio>
extern char* msg;
void sayHello()
{
    printf("%s", msg);
}

g++ ऊपर की दोनों कोड फ़ाइलों को सही compile करके Hello World! print करता है, लेकिन अगर source1.cpp के msg पर static लगा दें, तो undefined reference to 'msg' compile error आएगा:

// source1.cpp
extern void sayHello();
static const char* msg = "Hello World!\n";
int main()
{
    sayHello();
    return 0;
}

C++ static मेंबर और lifetime¶

लेखक के बारे में¶

संबंधित विषय¶

टिप्पणियाँ