C ++ में स्थिर कीवर्ड और इसके विभिन्न उपयोग हैं

Question

कीवर्ड staticवह है जिसका C ++ में कई अर्थ हैं जो मुझे बहुत भ्रामक लगते हैं और मैं अपने दिमाग को कभी इधर उधर नहीं कर सकता कि इसका वास्तव में कैसे काम करना है।

जो मैं समझता हूं कि staticभंडारण की अवधि है, जिसका अर्थ है कि यह वैश्विक के मामले में कार्यक्रम के जीवनकाल के लिए रहता है, लेकिन जब आप स्थानीय के बारे में बात कर रहे हैं, तो इसका मतलब है कि यह डिफ़ॉल्ट रूप से शून्य है।

C ++ मानक कीवर्ड के साथ वर्ग डेटा सदस्यों के लिए यह कहता है static:

3.7.1 स्थिर भंडारण अवधि [basic.stc.static]

3 स्थैतिक भंडारण अवधि के साथ एक स्थानीय चर घोषित करने के लिए कीवर्ड स्टेटिक का उपयोग किया जा सकता है।

4 एक वर्ग परिभाषा में एक वर्ग डेटा सदस्य के लिए लागू कीवर्ड स्थैतिक डेटा सदस्य स्थिर भंडारण अवधि देता है।

स्थानीय चर के साथ इसका क्या मतलब है ? क्या यह एक फ़ंक्शन स्थानीय चर है? क्योंकि यह भी है कि जब आप किसी फ़ंक्शन को स्थानीय घोषित करते हैं, तो staticयह केवल एक बार शुरू होता है, पहली बार यह फ़ंक्शन में प्रवेश करता है।

यह वर्ग के सदस्यों के संबंध में केवल भंडारण की अवधि के बारे में बात करता है, इसके बारे में क्या गैर उदाहरण विशिष्ट है, यह भी कोई संपत्ति staticनहीं है? या कि भंडारण अवधि है?

अब केस staticऔर फाइल स्कोप का क्या? क्या सभी वैश्विक चर को डिफ़ॉल्ट रूप से स्थिर भंडारण अवधि माना जाता है? निम्नलिखित (खंड 3.7.1 से) ऐसा प्रतीत होता है:

1 सभी चर जिनके पास गतिशील भंडारण अवधि नहीं है, थ्रेड स्टोरेज अवधि नहीं है, और स्थानीय नहीं हैं स्थिर भंडारण अवधि है। इन संस्थाओं के लिए भंडारण कार्यक्रम की अवधि (3.6.2, 3.6.3) तक रहेगा

staticएक चर के लिंकेज से कैसे संबंधित है?

यह पूरा staticकीवर्ड सर्वथा भ्रमित करने वाला है, क्या कोई इसके लिए विभिन्न उपयोगों को अंग्रेजी में स्पष्ट कर सकता है और मुझे यह भी बता सकता है किstatic कक्षा सदस्य को आरम्भ करने के लिए कब ?

Comments

— संबं धत लं क

Answer 1

चर:

staticअनुवाद इकाई के "आजीवन" के लिए चर मौजूद हैं जिन्हें इसमें परिभाषित किया गया है और:

• यदि यह नाम स्थान के दायरे (अर्थात कार्यों और कक्षाओं के बाहर) में है, तो इसे किसी अन्य अनुवाद इकाई से एक्सेस नहीं किया जा सकता है। इसे "आंतरिक लिंकेज" या "स्थिर भंडारण अवधि" के रूप में जाना जाता है। (सिवाय इसके शीर्षलेखों में मत करो constexpr। कुछ और, और आप प्रत्येक अनुवाद इकाई में एक अलग चर के साथ समाप्त होते हैं, जो कि भ्रामक है)
• यदि यह किसी फ़ंक्शन में एक चर है , तो इसे किसी अन्य स्थानीय चर की तरह फ़ंक्शन के बाहर से एक्सेस नहीं किया जा सकता है। (यह स्थानीय उन्होंने उल्लेख किया है)
• कक्षा के सदस्यों के पास कोई प्रतिबंधित गुंजाइश नहीं है static, लेकिन कक्षा से एक उदाहरण (जैसे std::string::npos) से संबोधित किया जा सकता है । [नोट: आप एक वर्ग में स्थिर सदस्यों की घोषणा कर सकते हैं , लेकिन उन्हें आमतौर पर अभी भी एक अनुवाद इकाई (सीपीपी फ़ाइल) में परिभाषित किया जाना चाहिए , और इस तरह, प्रति वर्ग में केवल एक ही है]

कोड के रूप में स्थान:

static std::string namespaceScope = "Hello";
void foo() {
    static std::string functionScope= "World";
}
struct A {
   static std::string classScope = "!";
};

अनुवाद इकाई में किसी भी फ़ंक्शन को निष्पादित करने से पहले (संभवतः mainनिष्पादन शुरू होने के बाद ), उस अनुवाद इकाई में स्थिर भंडारण अवधि (नाम स्थान गुंजाइश) वाले चर "निरंतर आरंभिक" ( constexprजहां संभव हो, या शून्य अन्यथा), और फिर गैर- स्थानीय लोगों "गतिशील प्रारंभ" कर रहे हैं ठीक से आदेश वे अनुवाद इकाई में परिभाषित कर रहे हैं में (चीजों के लिए की तरह std::string="HI";है कि नहीं कर रहे हैं constexpr)। अंत में, फ़ंक्शन-स्थानीय स्टेटिक्स को पहली बार निष्पादन "पहुंच" लाइन पर आरंभ किया जाएगा जहां वे घोषित किए जाते हैं। सभी staticचर सभी शुरुआती के रिवर्स ऑर्डर में नष्ट हो गए।

इस सभी अधिकार को प्राप्त करने का सबसे आसान तरीका सभी स्थिर वैरिएबल बनाना है constexprजो फ़ंक्शन स्टेटिक लोकल में आरंभीकृत नहीं होते हैं , जो यह सुनिश्चित करता है कि आपके सभी स्टेटिक्स / ग्लोबल्स को ठीक से आरम्भ किया जाता है जब आप उनका उपयोग करने की कोशिश करते हैं, तो कोई फर्क नहीं पड़ता कि इस प्रकार स्थैतिक आरंभीकरण को रोकना है। आदेश उपद्रव ।

T& get_global() {
    static T global = initial_value();
    return global;
}

सावधान रहें, क्योंकि जब नाम कहता है कि नेमस्पेस-स्कोप वैरिएबल में डिफ़ॉल्ट रूप से "स्टैटिक स्टोरेज अवधि" होती है, तो उनका मतलब "ट्रांसलेशन यूनिट के जीवनकाल" से है, लेकिन इसका मतलब यह नहीं है कि इसे फ़ाइल के बाहर एक्सेस नहीं किया जा सकता है।

कार्य

बहुत अधिक स्पष्ट रूप से, staticअक्सर एक वर्ग के सदस्य फ़ंक्शन के रूप में उपयोग किया जाता है, और केवल बहुत ही कम बार एक स्वतंत्र कार्य के लिए उपयोग किया जाता है।

एक स्थिर सदस्य फ़ंक्शन एक नियमित सदस्य फ़ंक्शन से भिन्न होता है जिसमें इसे एक वर्ग के उदाहरण के बिना कहा जा सकता है, और चूंकि इसमें कोई उदाहरण नहीं है, इसलिए यह कक्षा के गैर-स्थिर सदस्यों तक नहीं पहुंच सकता है। जब आप किसी वर्ग के लिए कोई फ़ंक्शन करना चाहते हैं, तो निश्चित रूप से स्थैतिक चर उपयोगी होते हैं, जो निश्चित रूप से किसी भी उदाहरण के सदस्यों को संदर्भित नहीं करता है, या किसी अन्य staticचर को प्रबंधित करने के लिए ।

struct A {
    A() {++A_count;}
    A(const A&) {++A_count;}
    A(A&&) {++A_count;}
    ~A() {--A_count;}

    static int get_count() {return A_count;}
private:
    static int A_count;
}

int main() {
    A var;

    int c0 = var.get_count(); //some compilers give a warning, but it's ok.
    int c1 = A::get_count(); //normal way
}

एक staticफ्री-फंक्शन का मतलब है कि फ़ंक्शन को किसी अन्य अनुवाद इकाई द्वारा संदर्भित नहीं किया जाएगा, और इस प्रकार लिंकर इसे पूरी तरह से अनदेखा कर सकता है। इसके बहुत कम उद्देश्य हैं:

• एक cpp फ़ाइल में इस्तेमाल किया जा सकता है यह सुनिश्चित करने के लिए कि फ़ंक्शन का उपयोग किसी अन्य फ़ाइल से कभी नहीं किया गया है।
• एक हेडर में रखा जा सकता है और हर फाइल में फ़ंक्शन की अपनी प्रति होगी। उपयोगी नहीं है, क्योंकि इनलाइन बहुत समान काम करता है।
• काम को कम करके लिंक समय को गति देता है
• प्रत्येक अनुवाद इकाई में एक ही नाम के साथ एक फ़ंक्शन रख सकते हैं, और वे सभी अलग-अलग काम कर सकते हैं। उदाहरण के लिए, आप static void log(const char*) {}प्रत्येक cpp फ़ाइल में एक डाल सकते हैं , और वे प्रत्येक अलग तरीके से लॉग इन कर सकते हैं।

Comments

कक्षा के सदस्यों के बारे में क्या? क्या यह तीसरा अलग मामला नहीं है?

— .tienne

@ इटेन - स्थिर वर्ग डेटा सदस्य स्थिर वैश्विक चर के समान होते हैं सिवाय इसके कि आप उन्हें अन्य अनुवाद इकाइयों से एक्सेस कर सकते हैं, और किसी भी एक्सेस (सदस्य कार्यों को छोड़कर) को classname::गुंजाइश निर्दिष्ट करनी चाहिए । स्टैटिक क्लास के सदस्य फ़ंक्शंस वैश्विक फ़ंक्शंस की तरह होते हैं लेकिन क्लास में स्कॉप किए जाते हैं, या सामान्य सदस्यों की तरह लेकिन बिना this(यह पसंद नहीं है - उन दोनों को समान होना चाहिए)।

— 223 पर स्टीव 314

@LuchianGrigore: जब मैं आपकी बात देखता हूं, तो मुझे यकीन नहीं होता कि इसका उपयोग करने के लिए क्या शब्द है।

— मूविंग डक

@ स्टीव ३१४: मैं समझता हूं कि आपका क्या मतलब है, लेकिन जब स्थैतिक रूप से अति-अतिभारित शब्द के साथ काम करते हैं , तो मैं चाहता हूं कि हम सभी थोड़ा अधिक सावधान थे। विशेष रूप से सभी वैश्विक (वास्तव में नाम स्थान स्तर) चर में स्थिर अवधि होती है, इसलिए स्थैतिक वैश्विक चर में स्थैतिक को जोड़ने के रूप में समझा जा सकता है namespace A { static int x; }, जिसका अर्थ आंतरिक संबंध है और यह स्थिर वर्ग डेटा सदस्यों के व्यवहार से बहुत अलग है ।

— डेविड रॉड्रिग्ज - dribeas

"अगर यह किसी नाम स्थान के दायरे में है, तो इसे किसी अन्य अनुवाद इकाई से एक्सेस नहीं किया जा सकता है ..." यदि नाम स्थान के दायरे में है तो इसका क्या मतलब है? क्या ऐसा हमेशा नहीं होता है, क्या आप एक उदाहरण और एक काउंटर उदाहरण दे सकते हैं?

— AturSams

Answer 2

स्टेटिक स्टोरेज अवधि का मतलब है कि प्रोग्राम के जीवनकाल के दौरान चर स्मृति में एक ही स्थान पर रहता है।

लिंकेज इसके लिए ऑर्थोगोनल है।

मुझे लगता है कि यह सबसे महत्वपूर्ण अंतर है जिसे आप कर सकते हैं।इसे और बाकी को समझें, साथ ही इसे याद रखना, आसान आना चाहिए (सीधे @Tony को संबोधित नहीं करना चाहिए, लेकिन जो भविष्य में इसे पढ़ सकता है)।

कीवर्ड staticका उपयोग आंतरिक लिंकेज और स्थिर भंडारण को दर्शाने के लिए किया जा सकता है , लेकिन संक्षेप में ये अलग हैं।

स्थानीय चर के साथ इसका क्या मतलब है? क्या यह एक फ़ंक्शन स्थानीय चर है?

हाँ। भले ही जब चर आरंभीकृत किया जाता है (फ़ंक्शन पर पहले कॉल पर और जब निष्पादन पथ घोषणा बिंदु तक पहुंचता है), तो यह प्रोग्राम के जीवन के लिए स्मृति में एक ही स्थान पर निवास करेगा। इस मामले में, staticयह स्थिर भंडारण देता है।

अब स्टेटिक और फाइल स्कोप वाले मामले का क्या? क्या सभी वैश्विक चर को डिफ़ॉल्ट रूप से स्थिर भंडारण अवधि माना जाता है?

हां, सभी ग्लोबल्स की परिभाषा स्थिर भंडारण अवधि है (अब जब हमने साफ किया कि इसका क्या मतलब है)। लेकिन नेमस्पेस स्कोप्ड वैरिएबल के साथ घोषित नहीं किया जाता है static, क्योंकि इससे उन्हें आंतरिक लिंकेज मिलेगा, इसलिए प्रति अनुवाद इकाई।

स्थिर एक चर के लिंकेज से कैसे संबंधित है?

यह नेमस्पेस-स्कूप्ड वैरिएबल इंटरनल लिंकेज देता है। यह सदस्यों और स्थानीय चर स्थिर भंडारण अवधि देता है।

आइए इस सब पर विस्तार करें:

//

static int x; //internal linkage
              //non-static storage - each translation unit will have its own copy of x
              //NOT A TRUE GLOBAL!

int y;        //static storage duration (can be used with extern)
              //actual global
              //external linkage
struct X
{
   static int x;     //static storage duration - shared between class instances 
};

void foo()
{
   static int x;     //static storage duration - shared between calls
}

यह संपूर्ण स्थिर खोजशब्द सर्वथा भ्रमित करने वाला है

निश्चित रूप से, जब तक आप इससे परिचित न हों। :) भाषा में नए कीवर्ड जोड़ने से बचने की कोशिश करते हुए, समिति ने इस, आईएमओ को इस प्रभाव के लिए फिर से इस्तेमाल किया - भ्रम। इसका उपयोग विभिन्न चीजों को इंगित करने के लिए किया जाता है (मैं कह सकता हूं, शायद चीजों का विरोध करता हूं)।

Comments

मुझे इसे सीधे करने दें - आप कह रहे हैं कि जब मैं static int xनेमस्पेस स्कोप में कहता हूं , तो यह गैर-स्टैटिक स्टोरेज देता है ।

— माइकल हगर

Answer 3

प्रश्न को स्पष्ट करने के लिए, मैं तीन अलग-अलग रूपों में 'स्थिर' कीवर्ड के उपयोग को श्रेणीबद्ध करना चाहूंगा:

(ए)। चर

(बी)। कार्यों

(सी)। सदस्य चर / वर्गों के कार्य

प्रत्येक उप शीर्षकों के लिए स्पष्टीकरण नीचे दिया गया है:

(ए) चर के लिए 'स्थिर' कीवर्ड

यह थोड़ा मुश्किल हो सकता है, लेकिन अगर समझाया जाए और ठीक से समझा जाए, तो यह बहुत सीधा है।

इसे समझाने के लिए, पहले यह गुंजाइश, अवधि और लिंकेज के बारे में जानने के लिए वास्तव में उपयोगी है चर के , जिसके बिना स्टैक कीवर्ड की मुखर अवधारणा के माध्यम से चीजें देखना हमेशा मुश्किल होता है।

1. स्कोप : यह निर्धारित करता है कि फ़ाइल में कहाँ, चर सुलभ है। यह दो प्रकार का हो सकता है: (i) स्थानीय या ब्लॉक स्कोप । (ii) ग्लोबल स्कोप

2. अवधि : एक चर बनाया और नष्ट कर दिया है जब निर्धारित करता है। फिर से यह दो प्रकार का होता है: (i) स्वचालित भंडारण अवधि (स्थानीय या ब्लॉक स्कोप वाले चर के लिए)। (ii) स्टेटिक स्टोरेज अवधि (ग्लोबल स्पेस या वैरिएबल वाले वेरिएबल के लिए (किसी फंक्शन में या कोड ब्लॉक में) स्टेटिक स्पेसियर के साथ )।

3. लिंकेज : यह निर्धारित करता है कि एक चर को किसी अन्य फ़ाइल में एक्सेस (या लिंक) किया जा सकता है या नहीं। फिर और (सौभाग्य से) यह दो प्रकार का होता है: (i) इंटरनल लिंकेज (वैरिएबल के लिए ब्लॉक स्कोप और ग्लोबल स्कोप / फाइल स्कोप / ग्लोबल नेमस्पेस स्कोप) (ii) एक्सटर्नल लिंकेज वाले वेरिएबल के लिए (वैरिएबल के लिए केवल ग्लोबल स्कोप / फाइल स्कोप / के लिए) ग्लोबल नेमस्पेस स्कोप)

चलो सादा वैश्विक और स्थानीय चर की बेहतर समझ के लिए नीचे एक उदाहरण देखें (स्थैतिक भंडारण अवधि के साथ कोई स्थानीय चर नहीं)

//main file
#include <iostream>

int global_var1; //has global scope
const global_var2(1.618); //has global scope

int main()
{
//these variables are local to the block main.
//they have automatic duration, i.e, they are created when the main() is 
//  executed and destroyed, when main goes out of scope
 int local_var1(23);
 const double local_var2(3.14);

 {
/* this is yet another block, all variables declared within this block are 
 have local scope limited within this block. */
// all variables declared within this block too have automatic duration, i.e, 
/*they are created at the point of definition within this block,
 and destroyed as soon as this block ends */
   char block_char1;
   int local_var1(32) //NOTE: this has been re-declared within the block, 
//it shadows the local_var1 declared outside

 std::cout << local_var1 <<"\n"; //prints 32

  }//end of block
  //local_var1 declared inside goes out of scope

 std::cout << local_var1 << "\n"; //prints 23

 global_var1 = 29; //global_var1 has been declared outside main (global scope)
 std::cout << global_var1 << "\n"; //prints 29
 std::cout << global_var2 << "\n"; //prints 1.618

 return 0;
}  //local_var1, local_var2 go out of scope as main ends
//global_var1, global_var2 go out of scope as the program terminates 
//(in this case program ends with end of main, so both local and global
//variable go out of scope together

अब आता है लिंकेज का कॉन्सेप्ट। जब एक फ़ाइल में परिभाषित एक वैश्विक चर को दूसरी फ़ाइल में उपयोग करने का इरादा होता है, तो चर का लिंक एक महत्वपूर्ण भूमिका निभाता है।

वैश्विक चर का लिंकेज खोजशब्दों द्वारा निर्दिष्ट किया गया है: (i) स्थिर , और (ii) बाहरी

(अब आप स्पष्टीकरण प्राप्त करें)

स्थैतिक कीवर्ड को स्थानीय और वैश्विक क्षेत्र के साथ चर पर लागू किया जा सकता है, और दोनों ही मामलों में, उनका मतलब अलग-अलग चीजों से है। मैं पहले 'स्थिर' कीवर्ड के उपयोग को वैश्विक दायरे वाले वेरिएबल्स (जहां मैं कीवर्ड 'एक्सटर्न' के उपयोग को स्पष्ट करता हूं) और बाद में स्थानीय दायरे वाले लोगों के लिए उपयोग के बारे में बताऊंगा।

1. वैश्विक दायरे वाले चर के लिए स्टेटिक कीवर्ड

वैश्विक चर की स्थिर अवधि होती है, जिसका अर्थ है कि वे उस दायरे से बाहर नहीं जाते हैं जब कोड का एक विशेष ब्लॉक (उदाहरण के लिए मुख्य ()) जिसमें इसका उपयोग किया जाता है। लिंकेज के आधार पर, उन्हें या तो केवल उसी फ़ाइल के भीतर एक्सेस किया जा सकता है, जहां उन्हें (स्थिर वैश्विक चर के लिए) घोषित किया जाता है, या फ़ाइल के बाहर भी फ़ाइल जिसमें वे घोषित किए जाते हैं (बाहरी प्रकार वैश्विक चर)

बाह्य चर वाले एक वैश्विक चर के मामले में, और यदि इस चर को उस फ़ाइल के बाहर एक्सेस किया जा रहा है जिसमें इसे आरंभिक रूप से दिया गया है, तो इसे उस फ़ाइल में घोषित किया जाना है जहाँ इसका उपयोग किया जा रहा है, जैसे किसी फ़ंक्शन को आगे करना है। यह घोषित किया जाता है कि यह परिभाषा एक फ़ाइल में है जहाँ से इसका उपयोग किया जा रहा है।

इसके विपरीत, यदि वैश्विक चर में स्थिर कीवर्ड है, तो इसका उपयोग उस फ़ाइल के बाहर नहीं किया जा सकता है, जिसके बारे में यह घोषित किया गया है।

(स्पष्टीकरण के लिए नीचे उदाहरण देखें)

उदाहरण के लिए:

//main2.cpp
 static int global_var3 = 23;  /*static global variable, cannot be                            
                                accessed in anyother file */
 extern double global_var4 = 71; /*can be accessed outside this file                  linked to main2.cpp */
 int main() { return 0; }

main3.cpp

//main3.cpp
#include <iostream>

int main()
{
   extern int gloabl_var4; /*this variable refers to the gloabal_var4
                            defined in the main2.cpp file */
  std::cout << global_var4 << "\n"; //prints 71;

  return 0;
}

अब c ++ में कोई भी वैरिएबल या तो एक कॉन्स्टेबल या नॉन-कास्ट हो सकता है और प्रत्येक 'कॉन्स्ट-नेस' के लिए हमें डिफ़ॉल्ट c ++ लिंकेज के दो मामले मिलते हैं, यदि कोई भी निर्दिष्ट नहीं है:

(i) यदि कोई ग्लोबल वैरिएबल नॉन-कास्ट है, तो इसका लिंकेज डिफॉल्ट रूप से एक्सटर्नल होता है , यानी नॉन-कास्ट वैरिएबल वैरिएबल को दूसरे में एक्सेस किया जा सकता है। एक्सटर्नल कीवर्ड (अन्य शब्दों में, नॉन कास्ट ग्लोबल) का उपयोग करके फॉरवर्ड डिक्लेरेशन द्वारा फाइल करें। चर में बाहरी जुड़ाव होता है (पाठ्यक्रम की स्थिर अवधि के साथ)। मूल फ़ाइल में एक्सटर्नल कीवर्ड का उपयोग जहाँ इसे परिभाषित किया गया है वह बेमानी है। इस मामले में बाहरी फ़ाइल के लिए गैर-कॉस्ट ग्लोबल वैरिएबल को अप्राप्य बनाने के लिए, वेरिएबल के प्रकार से पहले स्पेसियर 'स्टेटिक' का उपयोग करें। ।

(ii) यदि कोई ग्लोबल वैरिएबल कांस्टेबल है, तो इसका लिंकेज डिफ़ॉल्ट रूप से स्टैटिक है , अर्थात एक कॉन्स्टेबल वैरिएबल वैरिएबल को किसी फाइल में एक्सेस नहीं किया जा सकता है, जहां इसे परिभाषित किया गया है, (दूसरे शब्दों में, कॉन्स्टेबल वैरिएबल में इंटरनल लिंकेज है (स्टैटिक अवधि के साथ) बेशक))। एक स्थिर वैश्विक चर को किसी अन्य फ़ाइल में एक्सेस होने से रोकने के लिए स्थैतिक कीवर्ड का उपयोग भी बेमानी है। यहाँ, एक कॉस्ट ग्लोबल वैरिएबल में एक बाहरी लिंकेज है, वेरिएबल के प्रकार से पहले स्पेसर 'एक्सटर्नल' का उपयोग करें

यहां विभिन्न लिंक के साथ वैश्विक गुंजाइश चर के लिए एक सारांश है

//globalVariables1.cpp 

// defining uninitialized vairbles
int globalVar1; //  uninitialized global variable with external linkage 
static int globalVar2; // uninitialized global variable with internal linkage
const int globalVar3; // error, since const variables must be initialized upon declaration
const int globalVar4 = 23; //correct, but with static linkage (cannot be accessed outside the file where it has been declared*/
extern const double globalVar5 = 1.57; //this const variable ca be accessed outside the file where it has been declared

आगे हम जांच करते हैं कि उपरोक्त वैश्विक चर एक अलग फ़ाइल में एक्सेस करने पर कैसे व्यवहार करते हैं।

//using_globalVariables1.cpp (eg for the usage of global variables above)

// Forward declaration via extern keyword:
 extern int globalVar1; // correct since globalVar1 is not a const or static
 extern int globalVar2; //incorrect since globalVar2 has internal linkage
 extern const int globalVar4; /* incorrect since globalVar4 has no extern 
                         specifier, limited to internal linkage by
                         default (static specifier for const variables) */
 extern const double globalVar5; /*correct since in the previous file, it 
                           has extern specifier, no need to initialize the
                       const variable here, since it has already been
                       legitimately defined perviously */

2. स्थानीय स्कोप वाले चर के लिए स्टेटिक कीवर्ड

स्थानीय दायरे में चर के लिए स्थैतिक कीवर्ड पर अपडेट (अगस्त 2019)

इसे आगे दो श्रेणियों में विभाजित किया जा सकता है:

(i) किसी फ़ंक्शन ब्लॉक के भीतर चर के लिए स्थिर कीवर्ड , और (ii) अनाम स्थानीय ब्लॉक के भीतर चर के लिए स्थिर कीवर्ड।

(i) किसी फंक्शन ब्लॉक के भीतर वैरिएबल के लिए स्थिर कीवर्ड।

इससे पहले, मैंने उल्लेख किया कि स्थानीय दायरे वाले चरों की स्वचालित अवधि होती है, अर्थात जब ब्लॉक में प्रवेश किया जाता है तो वे मौजूद होते हैं (जैसा कि यह एक सामान्य ब्लॉक है, यह एक फ़ंक्शन ब्लॉक है) और ब्लॉक समाप्त होने पर मौजूद रहने का संकेत देता है, लंबी कहानी छोटी, चर स्थानीय दायरे में स्वचालित अवधि और स्वचालित अवधि चर (और ऑब्जेक्ट) का कोई लिंकेज है जिसका अर्थ है कि वे कोड ब्लॉक के बाहर दिखाई नहीं देते हैं।

यदि किसी फ़ंक्शन ब्लॉक के भीतर स्थैतिक विनिर्देशक को स्थानीय चर पर लागू किया जाता है, तो यह परिवर्तनशील की अवधि को स्वचालित से स्थैतिक में बदल देता है और इसका जीवन काल कार्यक्रम की पूरी अवधि है, जिसका अर्थ है कि इसमें एक निश्चित मेमोरी लोकेशन है और इसका मान केवल आरंभीकृत है एक बार कार्यक्रम शुरू होने से पहले cpp संदर्भ में बताया गया है (आरंभीकरण को असाइनमेंट के साथ भ्रमित नहीं होना चाहिए)

एक उदाहरण पर एक नज़र डालते हैं।

//localVarDemo1.cpp    
 int localNextID()
{
  int tempID = 1;  //tempID created here
  return tempID++; //copy of tempID returned and tempID incremented to 2
} //tempID destroyed here, hence value of tempID lost

int newNextID()
{
  static int newID = 0;//newID has static duration, with internal linkage
  return newID++; //copy of newID returned and newID incremented by 1
}  //newID doesn't get destroyed here :-)


int main()
{
  int employeeID1 = localNextID();  //employeeID1 = 1
  int employeeID2 = localNextID();  // employeeID2 = 1 again (not desired)
  int employeeID3 = newNextID(); //employeeID3 = 0;
  int employeeID4 = newNextID(); //employeeID4 = 1;
  int employeeID5 = newNextID(); //employeeID5 = 2;
  return 0;
}

स्थिर स्थानीय चर और स्थिर वैश्विक चर के लिए उपरोक्त मानदंड को देखते हुए, किसी को यह पूछने के लिए लुभाया जा सकता है कि उनके बीच क्या अंतर हो सकता है। जबकि वैश्विक चर कोड के भीतर किसी भी बिंदु पर जाया जा सकता है (एक ही साथ ही विभिन्न अनुवाद इकाई पर निर्भर करता है में स्थिरांक -नेस और निर्वासन -नेस), एक स्थिर चर एक समारोह ब्लॉक के भीतर परिभाषित सीधा नहीं पहुंचा। चर को फ़ंक्शन मान या संदर्भ द्वारा लौटाया जाना है। इसे एक उदाहरण द्वारा प्रदर्शित करें:

//localVarDemo2.cpp 

//static storage duration with global scope 
//note this variable can be accessed from outside the file
//in a different compilation unit by using `extern` specifier
//which might not be desirable for certain use case.
static int globalId = 0;

int newNextID()
{
  static int newID = 0;//newID has static duration, with internal linkage
  return newID++; //copy of newID returned and newID incremented by 1
}  //newID doesn't get destroyed here


int main()
{
    //since globalId is accessible we use it directly
  const int globalEmployee1Id = globalId++; //globalEmployeeId1 = 0;
  const int globalEmployee2Id = globalId++; //globalEmployeeId1 = 1;

  //const int employeeID1 = newID++; //this will lead to compilation error since newID++ is not accessible direcly. 
  int employeeID2 = newNextID(); //employeeID3 = 0;
  int employeeID2 = newNextID(); //employeeID3 = 1;

  return 0;
}

स्थैतिक वैश्विक और स्थिर स्थानीय चर की पसंद के बारे में अधिक स्पष्टीकरण इस स्टैकओवरफ्लो थ्रेड पर पाया जा सकता है

(ii) एक अनाम स्थानीय ब्लॉक के भीतर चर के लिए स्थिर कीवर्ड।

स्थानीय ब्लॉक के दायरे से बाहर जाने के बाद एक स्थानीय ब्लॉक (एक फ़ंक्शन ब्लॉक नहीं) के भीतर स्थिर चर को ब्लॉक के बाहर एक्सेस नहीं किया जा सकता है। इस नियम के लिए कोई चेतावनी नहीं है।

    //localVarDemo3.cpp 
    int main()
    {

      {
          const static int static_local_scoped_variable {99};
      }//static_local_scoped_variable goes out of scope

      //the line below causes compilation error
      //do_something is an arbitrary function
      do_something(static_local_scoped_variable);
      return 0;
    }

C ++ 11 ने कीवर्ड पेश किया constexprजो संकलन समय पर अभिव्यक्ति के मूल्यांकन की गारंटी देता है और कोड को अनुकूलित करने की अनुमति देता है। अब यदि किसी स्कोप के भीतर स्टैटिक कांस्टेबल वैरिएबल का मान कंपाइल टाइम पर जाना जाता है, तो कोड को उसी के अनुरूप तरीके से ऑप्टिमाइज़ किया जाता है constexpr। यहाँ एक छोटा सा उदाहरण है

मैं पाठकों को इस स्टैकओवरफ़्लो धागे में चर के बीच constexprऔर अंतर को देखने की भी सलाह देता हूं । यह वैरिएबल पर लागू होने वाले स्थिर कीवर्ड के लिए मेरे स्पष्टीकरण का निष्कर्ष निकालता है।static const

कार्यों के लिए इस्तेमाल किया जाने वाला बी 'स्थिर' कीवर्ड

कार्यों के संदर्भ में, स्थैतिक कीवर्ड का सीधा अर्थ है। यहाँ, यह फ़ंक्शन के लिंकेज को संदर्भित करता है आम तौर पर एक सीपीपी फ़ाइल के भीतर घोषित सभी कार्यों में डिफ़ॉल्ट रूप से बाहरी लिंकेज होता है, अर्थात एक फ़ाइल में परिभाषित एक फ़ंक्शन को आगे की घोषणा के द्वारा दूसरे सीपीपी फ़ाइल में उपयोग किया जा सकता है।

फ़ंक्शन की घोषणा से पहले एक स्थिर कीवर्ड का उपयोग आंतरिक से इसके लिंकेज को सीमित करता है , अर्थात इसकी परिभाषा के बाहर एक फ़ाइल के भीतर एक स्थिर फ़ंक्शन का उपयोग नहीं किया जा सकता है।

C. Staitc Keyword सदस्य चर और वर्गों के कार्यों के लिए उपयोग किया जाता है

1. कक्षाओं के सदस्य चर के लिए 'स्थिर' कीवर्ड

मैं यहां एक उदाहरण के साथ सीधे शुरुआत करता हूं

#include <iostream>

class DesignNumber
{
  private:

      static int m_designNum;  //design number
      int m_iteration;     // number of iterations performed for the design

  public:
    DesignNumber() {     }  //default constructor

   int  getItrNum() //get the iteration number of design
   {
      m_iteration = m_designNum++;
      return m_iteration;
   }
     static int m_anyNumber;  //public static variable
};
int DesignNumber::m_designNum = 0; // starting with design id = 0
                     // note : no need of static keyword here
                     //causes compiler error if static keyword used
int DesignNumber::m_anyNumber = 99; /* initialization of inclass public 
                                    static member  */
enter code here

int main()
{
   DesignNumber firstDesign, secondDesign, thirdDesign;
   std::cout << firstDesign.getItrNum() << "\n";  //prints 0
   std::cout << secondDesign.getItrNum() << "\n"; //prints 1
   std::cout << thirdDesign.getItrNum() << "\n";  //prints 2

   std::cout << DesignNumber::m_anyNumber++ << "\n";  /* no object
                                        associated with m_anyNumber */
   std::cout << DesignNumber::m_anyNumber++ << "\n"; //prints 100
   std::cout << DesignNumber::m_anyNumber++ << "\n"; //prints 101

   return 0;
}

इस उदाहरण में, स्थैतिक चर m_designNum अपना मान बनाए रखता है और यह एकल निजी सदस्य चर (क्योंकि यह स्थिर है) साझा किया जाता है b / w ऑब्जेक्ट प्रकार के सभी चर DesignNumber

अन्य सदस्य चर की तरह, किसी वर्ग के स्थिर सदस्य चर किसी भी वर्ग वस्तु से जुड़े नहीं होते हैं, जो मुख्य कार्य में किसी भी प्रकार की छपाई से प्रदर्शित होता है।

const बनाम non-const स्थिर सदस्य चर वर्ग में

(i) गैर-कास्ट क्लास स्थिर सदस्य चर पिछले उदाहरण में स्थिर सदस्य (सार्वजनिक और निजी दोनों) गैर स्थिरांक थे। आईएसओ मानक गैर-स्थिर स्थैतिक सदस्यों को कक्षा में आरंभीकृत करने से मना करता है। इसलिए पिछले उदाहरण के अनुसार, उन्हें वर्ग परिभाषा के बाद परिमाण में होना चाहिए, इस चेतावनी के साथ कि स्थैतिक कीवर्ड को छोड़ने की आवश्यकता है

(ii) कक्षा के कॉन्स्टेबल-स्टैटिक मेंबर वेरिएबल यह सीधा है और अन्य कॉन्स्टेबल मेंबर वेरिएबल इनिशियलाइज़ेशन के कन्वेंशन के साथ जाता है, यानी क्लास के कॉस्ट स्टैटिक मेंबर वेरिएबल्स को डिक्लेरेशन के पॉइंट पर इनिशियलाइज़ किया जा सकता है और उन्हें इनिशियलाइज़ किया जा सकता है। एक वर्ग के साथ घोषणा की कक्षा कि परिभाषा के बाद शुरू होने पर कीवर्ड कांस्टेबल को स्थिर सदस्य में जोड़ने की आवश्यकता होती है।

हालांकि, मैं घोषणा के बिंदु पर कांस्टेबल स्थिर सदस्य चर को शुरू करने की सिफारिश करता हूं। यह मानक सी ++ सम्मेलन के साथ जाता है और कोड को साफ दिखता है

कक्षा में स्थैतिक सदस्य चर पर अधिक उदाहरण के लिए learncpp.com से निम्न लिंक देखें। http://www.learncpp.com/cpp-tutorial/811-static-member-variables/

2. कक्षाओं के सदस्य समारोह के लिए 'स्थिर' कीवर्ड

जैसे कक्षाओं के सदस्य चर, स्थिर हो सकते हैं, वैसे ही कक्षाओं के सदस्य कार्य कर सकते हैं। कक्षाओं के सामान्य सदस्य कार्य हमेशा वर्ग प्रकार के ऑब्जेक्ट के साथ जुड़े होते हैं। इसके विपरीत, किसी वर्ग के स्थिर सदस्य कार्य कक्षा की किसी भी वस्तु से संबद्ध नहीं होते हैं, अर्थात उनके पास यह * सूचक नहीं है।

दूसरी बात यह है कि वर्ग के स्थिर सदस्य कार्यों में कोई * सूचक नहीं है, इसलिए उन्हें मुख्य समारोह में वर्ग नाम और कार्यक्षेत्र संकल्प ऑपरेटर का उपयोग करके बुलाया जा सकता है (ClassName :: functionName ();)

किसी वर्ग का तीसरा स्थिर सदस्य कार्य केवल किसी वर्ग के स्थिर सदस्य चर का उपयोग कर सकता है, क्योंकि किसी वर्ग के गैर-स्थैतिक सदस्य चर वर्ग वस्तु से संबंधित होने चाहिए।

एक वर्ग में स्थिर सदस्य कार्यों पर अधिक उदाहरण के लिए learncpp.com से निम्न लिंक देखें

http://www.learncpp.com/cpp-tutorial/812-static-member-functions/

Comments

1) c ++ 17 से पहले केवल इंटीग्रल स्टेटिक कास्ट मेंबर वैरिएबल को इन-क्लास इनिशियलाइज़ किया जा सकता है, उदाहरण के struct Foo{static const std::string name = "cpp";};लिए एरर है, nameक्लास के बाहर परिभाषित किया जाना चाहिए; इनलाइन वैरिएबल के साथ c ++ 17 में इंट्रोड्यूस किया गया कोड struct Foo{static inline const std::string name = "cpp";};1 : 2) पब्लिक स्टैटिक मेंबर / मेंबर फंक्शंस को स्कोप रेजोल्यूशन ऑपरेटर के साथ क्लास नेम से एक्सेस किया जा सकता है और डॉट ऑपरेटर के साथ एक इंस्टेंस भी दिया जा सकता है (जैसे:

— example.some_static_method

"M_anyVariable" "m_anyNumber" नहीं बनना चाहिए? अपने अंतिम कोड उदाहरण में?

— गेबिसिमो

मैं जवाब की पूर्णता और शुद्धता का न्याय नहीं कर सकता, लेकिन यह वास्तव में व्यापक है और इसका पालन करना आसान था। आपका बहुत बहुत धन्यवाद! यदि आप इसे सुधारना चाहते हैं, तो शुरुआत में एक संक्षिप्त सारांश फायदेमंद हो सकता है क्योंकि यह काफी लंबा पाठ है और मुख्य बिंदुओं को एक नेस्टेड सूची या उन लोगों के लिए ट्री आरेख के रूप में आसानी से देखा जा सकता है, जो "आंतरिक / बाहरी" जैसे शब्दों को जानते हैं। संबंध "

— gebbissimo

Answer 4

यह वास्तव में काफी सरल है। यदि आप किसी चर को किसी कार्य के दायरे में स्थिर घोषित करते हैं, तो इसका मान उस फ़ंक्शन के क्रमिक कॉल के बीच संरक्षित है। इसलिए:

int myFun()
{
static int i=5;
i++;
return i;
}
int main()
{
printf("%d", myFun());
printf("%d", myFun());
printf("%d", myFun());
}

के 678बजाय दिखाएगा 666, क्योंकि यह बढ़े हुए मूल्य को याद करता है।

स्थिर सदस्यों के लिए, वे वर्ग के उदाहरणों में अपने मूल्य को संरक्षित करते हैं। तो निम्नलिखित कोड:

struct A
{
static int a;
};
int main()
{
A first;
A second;
first.a = 3;
second.a = 4;
printf("%d", first.a);
}

4 प्रिंट करेगा, क्योंकि first.a और second.a अनिवार्य रूप से एक ही चर हैं। आरंभीकरण के लिए, इस प्रश्न को देखें ।

Comments

यह नाम स्थान गुंजाइश चर को संबोधित नहीं करता है।

— माइकल हगर

Answer 5

जब आप staticफ़ाइल स्कोप पर एक वैरिएबल घोषित करते हैं , तो वह वैरिएबल केवल उस विशेष फ़ाइल (तकनीकी रूप से, * अनुवाद इकाई) में उपलब्ध होता है, लेकिन इसे बहुत अधिक जटिल नहीं करते हैं। उदाहरण के लिए:

a.cpp

static int x = 7;

void printax()
{
    cout << "from a.cpp: x=" << x << endl;
}

b.cpp

static int x = 9;

void printbx()
{
    cout << "from b.cpp: x=" << x << endl;
}

main.cpp:

int main(int, char **)
{
    printax(); // Will print 7
    printbx(); // Will print 9

    return 0;
}

एक के लिए स्थानीय चर, staticका मतलब है कि चर शून्य प्रारंभ होगा और कॉल के बीच अपने मूल्य को बनाए रखें:

unsigned int powersoftwo()
{
    static unsigned lastpow;

    if(lastpow == 0)
        lastpow = 1;
    else
        lastpow *= 2;

    return lastpow;
}

int main(int, char **)
{
    for(int i = 0; i != 10; i++)
        cout << "2^" << i << " = " << powersoftwo() << endl;
}

के लिए वर्ग चर, इसका मतलब है कि केवल चर कि उस वर्ग के सभी सदस्यों के बीच साझा किया जाता है का एक उदाहरण है कि वहाँ। अनुमतियों के आधार पर, चर को पूरी तरह से योग्य नाम का उपयोग करके कक्षा के बाहर से पहुँचा जा सकता है।

class Test
{
private:
    static char *xxx;

public:
    static int yyy;

public:
    Test()
    {        
        cout << this << "The static class variable xxx is at address "
             << static_cast<void *>(xxx) << endl;
        cout << this << "The static class variable yyy is at address "
             << static_cast<void *>(&y) << endl;
    }
};

// Necessary for static class variables.
char *Test::xxx = "I'm Triple X!";
int Test::yyy = 0;

int main(int, char **)
{
    Test t1;
    Test t2;

    Test::yyy = 666;

    Test t3;
};

एक गैर-वर्ग फ़ंक्शन को चिह्नित करना static, फ़ंक्शन को केवल उस फ़ाइल से पहुंच योग्य बनाता है और अन्य फ़ाइलों से दुर्गम होता है।

a.cpp

static void printfilename()
{ // this is the printfilename from a.cpp - 
  // it can't be accessed from any other file
    cout << "this is a.cpp" << endl;
}

b.cpp

static void printfilename()
{ // this is the printfilename from b.cpp - 
  // it can't be accessed from any other file
    cout << "this is b.cpp" << endl;
}

वर्ग के सदस्यों के कार्यों के लिए, उन्हें इस रूप में चिह्नित करना staticकि फ़ंक्शन को किसी ऑब्जेक्ट के किसी विशेष उदाहरण पर कॉल करने की आवश्यकता नहीं है (अर्थात इसमें thisपॉइंटर नहीं है )।

class Test
{
private:
    static int count;

public:
    static int GetTestCount()
    {
        return count;
    };

    Test()
    {
        cout << this << "Created an instance of Test" << endl;
        count++;
    }

    ~Test()
    {
        cout << this << "Destroyed an instance of Test" << endl;
        count--;
    }
};

int Test::count = 0;

int main(int, char **)
{
    Test *arr[10] = { NULL };

    for(int i = 0; i != 10; i++)
        arr[i] = new Test();

    cout << "There are " << Test::GetTestCount() << " instances of the Test class!" << endl;

    // now, delete them all except the first and last!
    for(int i = 1; i != 9; i++)
        delete arr[i];        

    cout << "There are " << Test::GetTestCount() << " instances of the Test class!" << endl;

    delete arr[0];

    cout << "There are " << Test::GetTestCount() << " instances of the Test class!" << endl;

    delete arr[9];

    cout << "There are " << Test::GetTestCount() << " instances of the Test class!" << endl;

    return 0;
}

Answer 6

स्टैटिक वेरिएबल्स प्रत्येक वर्ग के बजाय प्रत्येक वर्ग के अपने-अपने वेरिएबल के बीच साझा किए जाते हैं।

class MyClass
{
    public:
    int myVar; 
    static int myStaticVar;
};

//Static member variables must be initialized. Unless you're using C++11, or it's an integer type,
//they have to be defined and initialized outside of the class like this:
MyClass::myStaticVar = 0;

MyClass classA;
MyClass classB;

'MyClass' के प्रत्येक उदाहरण का अपना 'myVar' है, लेकिन वही 'myStaticVar' साझा करें। वास्तव में, आपको 'myStaticVar' तक पहुंचने के लिए MyClass के उदाहरण की भी आवश्यकता नहीं है, और आप इसे इस तरह से कक्षा के बाहर भी एक्सेस कर सकते हैं:

MyClass::myStaticVar //Assuming it's publicly accessible.

जब एक फ़ंक्शन को स्थानीय चर के रूप में उपयोग किया जाता है (और क्लास सदस्य-चर के रूप में नहीं) तो स्थिर कीवर्ड कुछ अलग करता है। यह आपको वैश्विक स्कोप दिए बिना, एक निरंतर चर बनाने की अनुमति देता है।

int myFunc()
{
   int myVar = 0; //Each time the code reaches here, a new variable called 'myVar' is initialized.
   myVar++;

   //Given the above code, this will *always* print '1'.
   std::cout << myVar << std::endl;

   //The first time the code reaches here, 'myStaticVar' is initialized. But ONLY the first time.
   static int myStaticVar = 0;

   //Each time the code reaches here, myStaticVar is incremented.
   myStaticVar++;

   //This will print a continuously incrementing number,
   //each time the function is called. '1', '2', '3', etc...
   std::cout << myStaticVar << std::endl;
}

यह दृढ़ता के संदर्भ में एक वैश्विक चर है ... लेकिन गुंजाइश / पहुंच में वैश्विक होने के बिना।

आपके पास स्थैतिक सदस्य कार्य भी हो सकते हैं। स्थैतिक कार्य मूल रूप से गैर-सदस्य कार्य हैं, लेकिन वर्ग के नाम के नामस्थान के अंदर, और कक्षा के सदस्यों के लिए निजी पहुंच के साथ।

class MyClass
{
    public:
    int Func()
    {
        //...do something...
    }

    static int StaticFunc()
    {
        //...do something...
    }
};

int main()
{
   MyClass myClassA;
   myClassA.Func(); //Calls 'Func'.
   myClassA.StaticFunc(); //Calls 'StaticFunc'.

   MyClass::StaticFunc(); //Calls 'StaticFunc'.
   MyClass::Func(); //Error: You can't call a non-static member-function without a class instance!

   return 0;
}

जब आप किसी सदस्य-फ़ंक्शन को कॉल करते हैं, तो 'इस' नामक एक छिपा हुआ पैरामीटर होता है, जो फ़ंक्शन को कॉल करने वाले वर्ग के उदाहरण के लिए एक संकेतक है। स्टैटिक सदस्य फ़ंक्शंस में वह छिपा हुआ पैरामीटर नहीं होता है ... वे बिना वर्ग उदाहरण के कॉल करने योग्य होते हैं, लेकिन वे किसी क्लास के गैर-स्थिर सदस्य चर तक भी नहीं पहुँच सकते, क्योंकि उनके पास काम करने के लिए 'यह' पॉइंटर नहीं होता है। उन्हें किसी विशिष्ट वर्ग के उदाहरण पर नहीं बुलाया जा रहा है।

Comments

"यह मानते हुए कि यह सार्वजनिक रूप से सुलभ है।" - यह।

— लुचियन ग्रिगोर

myStaticVarको भी परिभाषित करने की आवश्यकता है। Kinda का उल्लेख करना महत्वपूर्ण है कि जब staticकीवर्ड के शब्दार्थ के बारे में एक प्रश्न का उत्तर दिया जाए , तो क्या आपको नहीं लगता है?

— प्रेटोरियन

@Praetorian: धन्यवाद, निश्चित।

— 22-21

@JaminGrey "स्टैटिक स्टैंडअलोन" से मेरा मतलब स्टैटिक नॉन-मेंबर फ़ंक्शंस से था, और मैं ऐसे लिखता हूँ जब भी मुझे वर्तमान CPP फ़ाइल में कुछ नई कार्यक्षमता की आवश्यकता होती है, और लिंक करने वाले को अतिरिक्त सिंबल प्रोसेस करने की इच्छा नहीं होती है।

— वीआर

@ वीआर ऑड! मुझे कभी नहीं पता था कि कार्यक्षमता मौजूद थी। मेरे ज्ञान को व्यापक बनाने के लिए धन्यवाद!

— जामिन ग्रे

Answer 7

मैं एक सी प्रोग्रामर नहीं हूं, इसलिए मैं आपको सी प्रोग्राम में स्थैतिक के उपयोग के बारे में ठीक से जानकारी नहीं दे सकता, लेकिन जब ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग स्टैटिक की बात आती है तो मूल रूप से एक वैरिएबल, या एक फंक्शन या एक क्लास को समान घोषित करता है। कार्यक्रम के दौरान जीवन भर। उदाहरण के लिए।

class A
{
public:
    A();
    ~A();
    void somePublicMethod();
private:
    void somePrivateMethod();
};

जब आप इस क्लास को अपने मेंटेन करते हैं तो आप कुछ ऐसा करते हैं।

int main()
{
   A a1;
   //do something on a1
   A a2;
   //do something on a2
}

ये दो वर्ग उदाहरण एक दूसरे से पूरी तरह से अलग हैं और एक दूसरे से स्वतंत्र रूप से संचालित होते हैं। लेकिन अगर आप कक्षा ए को इस तरह से बनाना चाहते थे।

class A
{
public:
    A();
    ~A();
    void somePublicMethod();
    static int x;
private:
    void somePrivateMethod();
};

चलिए फिर से मुख्य की ओर लौटते हैं।

int main()
{
   A a1;
   a1.x = 1;
   //do something on a1
   A a2;
   a2.x++;
   //do something on a2
}

फिर a1 और a2 int x की एक ही प्रति साझा करेगा जिससे a1 में x पर कोई भी संचालन सीधे a2 में x के संचालन को प्रभावित करेगा। तो अगर मुझे ऐसा करना होता

int main()
{
   A a1;
   a1.x = 1;
   //do something on a1
   cout << a1.x << endl; //this would be 1
   A a2;
   a2.x++;
   cout << a2.x << endl; //this would be 2 
   //do something on a2
}

कक्षा ए के दोनों उदाहरण स्थिर चर और कार्यों को साझा करते हैं। उम्मीद है कि यह आपके प्रश्न का उत्तर देगा। C का मेरा सीमित ज्ञान मुझे यह कहने की अनुमति देता है कि किसी फ़ंक्शन या वैरिएबल को स्थिर के रूप में परिभाषित करने का मतलब है कि यह केवल उस फ़ाइल को दिखाई देता है जिसे फ़ंक्शन या वैरिएबल को स्टैटिक के रूप में परिभाषित किया गया है। लेकिन यह बेहतर होगा कि एक C लड़के द्वारा उत्तर दिया जाए और मुझे नहीं। C ++ आपके चर को स्थिर घोषित करने के C और C ++ दोनों तरीकों की अनुमति देता है क्योंकि यह C के साथ पूरी तरह से पीछे की ओर संगत है।

Answer 8

स्थानीय चर के साथ इसका क्या मतलब है? क्या यह एक फ़ंक्शन स्थानीय चर है?

हां - गैर-वैश्विक, जैसे कि फ़ंक्शन स्थानीय चर।

क्योंकि यह भी है कि जब आप किसी फ़ंक्शन को स्थैतिक के रूप में घोषित करते हैं कि यह केवल एक बार इनिशियलाइज़ होता है, तो पहली बार यह इस फंक्शन में प्रवेश करता है।

सही।

यह केवल वर्ग सदस्यों के संबंध में भंडारण की अवधि के बारे में बात करता है, इसके बारे में क्या है कि यह गैर-विशिष्ट है, यह भी स्थैतिक की संपत्ति है? या कि भंडारण अवधि है?

class R { static int a; }; // << static lives for the duration of the program

यह कहना है, Rशेयर के सभी उदाहरण int R::a- int R::aकभी भी कॉपी नहीं किया जाता है।

अब स्टेटिक और फाइल स्कोप वाले मामले का क्या?

प्रभावी रूप से एक वैश्विक जिसके पास कंस्ट्रक्टर / विध्वंसक है, जहां उपयुक्त - आरंभ तक पहुंच को स्थगित नहीं किया जाता है।

स्थिर एक चर के लिंकेज से कैसे संबंधित है?

एक फ़ंक्शन स्थानीय के लिए, यह बाहरी है। पहुंच: यह फ़ंक्शन तक पहुंच योग्य है (जब तक कि आप इसे वापस नहीं करते)।

एक वर्ग के लिए, यह बाहरी है। पहुँच: मानक पहुँच विनिर्देशक लागू होते हैं (सार्वजनिक, संरक्षित, निजी)।

static आंतरिक लिंकेज भी निर्दिष्ट कर सकता है, जहां यह घोषित किया गया है (फ़ाइल / नाम स्थान) पर निर्भर करता है।

यह संपूर्ण स्थिर खोजशब्द सर्वथा भ्रमित करने वाला है

C ++ में इसके कई उद्देश्य हैं।

क्या कोई इसके लिए अलग-अलग उपयोगों को स्पष्ट कर सकता है और यह भी बता सकता है कि एक स्थिर वर्ग के सदस्य को कब शुरू करना है?

mainयदि यह लोड किया गया है और इसके पास एक कंस्ट्रक्टर है, तो यह स्वचालित रूप से पहले इनिशियलाइज्ड है । यह एक अच्छी बात की तरह लग सकता है, लेकिन इनिशियलाइज़ेशन ऑर्डर काफी हद तक आपके नियंत्रण से परे है, इसलिए जटिल इनिशियलाइज़ेशन को बनाए रखना बहुत मुश्किल हो जाता है, और आप इसे कम से कम करना चाहते हैं - यदि आपके पास स्थैतिक होना चाहिए, तो पुस्तकालयों में स्थानीय तराजू बेहतर ढंग से कार्य करें और परियोजनाओं। जहां तक ​​स्टैटिक स्टोरेज अवधि वाले डेटा की बात है, तो आपको इस डिज़ाइन को कम से कम करने की कोशिश करनी चाहिए, खासकर अगर म्यूटेबल (वैश्विक चर)। आरंभिक 'समय' भी कई कारणों से भिन्न होता है - लोडर और कर्नेल में कुछ चरण होते हैं जो स्मृति के पैरों के निशान को कम करते हैं और प्रारंभ में डेटा पर निर्भर करते हुए आरंभीकरण को स्थगित कर देते हैं।

Answer 9

स्टेटिक ऑब्जेक्ट: हम स्थिर कीवर्ड का उपयोग करते हुए स्थिर वर्ग के सदस्यों को परिभाषित कर सकते हैं। जब हम किसी वर्ग के सदस्य को स्थैतिक घोषित करते हैं तो इसका अर्थ यह होता है कि वर्ग की कितनी भी वस्तुएँ नहीं बनी हैं, स्थैतिक सदस्य की केवल एक ही प्रति है।

एक स्थिर सदस्य को कक्षा की सभी वस्तुओं द्वारा साझा किया जाता है। जब कोई अन्य इनिशियलाइज़ेशन मौजूद न हो, तो सभी स्टैटिक डेटा को शून्य पर आरंभीकृत किया जाता है। हम इसे कक्षा की परिभाषा में नहीं डाल सकते, लेकिन इसे कक्षा के बाहर आरम्भ किया जा सकता है, जैसा कि निम्नलिखित उदाहरण में किया गया है, स्टैटिक वैरिएबल को फिर से परिभाषित करके, स्कोप रिज़ॉल्यूशन ऑपरेटर का उपयोग करके :: यह पहचानने के लिए कि यह किस वर्ग का है।

हमें स्थैतिक डेटा सदस्यों की अवधारणा को समझने के लिए निम्नलिखित उदाहरण का प्रयास करें:

#include <iostream>

using namespace std;

class Box
{
   public:
      static int objectCount;
      // Constructor definition
      Box(double l=2.0, double b=2.0, double h=2.0)
      {
         cout <<"Constructor called." << endl;
         length = l;
         breadth = b;
         height = h;
         // Increase every time object is created
         objectCount++;
      }
      double Volume()
      {
         return length * breadth * height;
      }
   private:
      double length;     // Length of a box
      double breadth;    // Breadth of a box
      double height;     // Height of a box
};

// Initialize static member of class Box
int Box::objectCount = 0;

int main(void)
{
   Box Box1(3.3, 1.2, 1.5);    // Declare box1
   Box Box2(8.5, 6.0, 2.0);    // Declare box2

   // Print total number of objects.
   cout << "Total objects: " << Box::objectCount << endl;

   return 0;
}

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है:

Constructor called.
Constructor called.
Total objects: 2

स्टेटिक फंक्शन मेंबर्स: एक फंक्शन मेंबर को स्टेटिक घोषित करके, आप इसे क्लास के किसी खास ऑब्जेक्ट से स्वतंत्र कर देते हैं। एक स्थिर सदस्य फ़ंक्शन को तब भी कहा जा सकता है, जब कक्षा की कोई भी वस्तु मौजूद न हो और केवल क्लास नाम और स्कोप रिज़ॉल्यूशन ऑपरेटर ::

एक स्थिर सदस्य फ़ंक्शन केवल स्थिर डेटा सदस्य, अन्य स्थिर सदस्य फ़ंक्शन और किसी भी अन्य फ़ंक्शन को कक्षा के बाहर से एक्सेस कर सकता है।

स्टैटिक सदस्य फ़ंक्शंस में क्लास स्कोप होता है और क्लास के इस पॉइंटर तक उनकी पहुँच नहीं होती है। आप यह निर्धारित करने के लिए एक स्थिर सदस्य फ़ंक्शन का उपयोग कर सकते हैं कि कक्षा की कुछ वस्तुएँ बनाई गई हैं या नहीं।

हमें स्थैतिक फ़ंक्शन सदस्यों की अवधारणा को समझने के लिए निम्नलिखित उदाहरण का प्रयास करें:

#include <iostream>

using namespace std;

class Box
{
   public:
      static int objectCount;
      // Constructor definition
      Box(double l=2.0, double b=2.0, double h=2.0)
      {
         cout <<"Constructor called." << endl;
         length = l;
         breadth = b;
         height = h;
         // Increase every time object is created
         objectCount++;
      }
      double Volume()
      {
         return length * breadth * height;
      }
      static int getCount()
      {
         return objectCount;
      }
   private:
      double length;     // Length of a box
      double breadth;    // Breadth of a box
      double height;     // Height of a box
};

// Initialize static member of class Box
int Box::objectCount = 0;

int main(void)
{

   // Print total number of objects before creating object.
   cout << "Inital Stage Count: " << Box::getCount() << endl;

   Box Box1(3.3, 1.2, 1.5);    // Declare box1
   Box Box2(8.5, 6.0, 2.0);    // Declare box2

   // Print total number of objects after creating object.
   cout << "Final Stage Count: " << Box::getCount() << endl;

   return 0;
}

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है:

Inital Stage Count: 0
Constructor called.
Constructor called.
Final Stage Count: 2

Comments

यह उल्लेख करना सही होगा कि इस प्रतिमान को Tutorialspoint.com/cplusplus/cpp_static_members.htm

— BugShotGG