स्थैतिक प्रारंभिकरण आदेश "फियास्को", सी ++

Question

एक बार जब मैं एक शानदार सी ++ एफएक्यू पढ़ रहा था (यह वास्तव में अच्छा है !! https://isocpp.org/faq) और स्थिर प्रारंभिक आदेश "फियास्को" को रोकने के तरीके के बारे में विषय पढ़ें। इसलिए लेखक स्थैतिक चर को कार्यों में लपेटने की सलाह देते हैं, इस प्रकार चर के निर्माण क्रम को बनाए रखकर "फियास्को" को रोकने के लिए। लेकिन यह मुझे एक कठोर कामकाज लगता है। तो मेरा सवाल यह है कि क्या इस "फियास्को" को रोकने के लिए कोई आधुनिक, अधिक पैटर्न उन्मुख तरीका है लेकिन "स्थिर सामग्री" को कार्यों में लपेटने के लिए ???

Answer 1

आधुनिक, अधिक पैटर्न उन्मुख तरह से पहली जगह में वैश्विक उपयोग करने के लिए नहीं है।

इसके आसपास कोई दूसरा रास्ता नहीं है।

यह अन्यथा "फियास्को" नहीं होगा, अन्यथा!

Answer 2

समस्या का समाधान करने का अधिक सामान्य तरीका है जब भी संभव हो वहां स्थिरता से बचें - और निर्माण आदेश पर भरोसा रखने वाली वस्तुओं के बीच और भी बहुत कुछ।

फिर आवश्यक क्रम में वस्तुओं का निर्माण करें। उदाहरण के लिए, अगर हम दो वस्तुओं x और y, और y के निर्माण है अगर एक्स का निर्माण नहीं किया गया है असफल हो जायेगी, तो x पहले का निर्माण और y के निर्माता (या किसी अन्य सदस्य))

SomeObject x; 
SomeOtherObject y(x); 

को यह आपूर्ति या

SomeObject *x = new SomeObject; 
SomeOtherObject y = new SomeObject(*x); 

(ऊपर के दोनों मान y के निर्माता के लिए एक संदर्भ की आवश्यकता है)।

यदि आपको कार्यों के बीच x और y साझा करने की आवश्यकता है, तो बस उन्हें तर्क के रूप में कार्य करने के लिए पास करें।

यदि आपको स्टेटिक्स का उपयोग करना चाहिए (यानी आप हर जगह तर्क पारित करने की टाइपिंग नहीं चाहते हैं) तो स्टेटस पॉइंटर्स बनें, और उन्हें एक बार शुरू करें (उदाहरण के लिए, main() में)।

// all source files can use x and y via these declarations (e.g. via a header file) 

extern SomeObject *x; 
extern SomeOtherObject *y; 

// definition in one source file only 

SomeObject *x; 
SomeOtherObject *y; 

int main() 
{ 
    x = new SomeObject; 
    y = new SomeOtherObject(*x); 

     // call other functions that use x and y. 

    delete y; 
    delete x; 
} 

लेकिन, वास्तव में, यदि संभव हो तो स्टेटिक्स का उपयोग करने से बचने के लिए सबसे अच्छा है।

Answer 3

तो मेरा सवाल यह है कि क्या इस "फियास्को" को रोकने के लिए कोई आधुनिक, अधिक पैटर्न उन्मुख तरीका है लेकिन "स्थिर सामग्री" को कार्यों में लपेटने के लिए ???

ज्यादातर मामलों में, आप मुख्य कार्य में अपने "वैश्विक" डेटा ऐलान करते हैं और निर्भरता इंजेक्शन का उपयोग जहां आवश्यक हो, चारों ओर इसे पारित कर सकते हैं। दूसरे शब्दों में, स्थिर स्थिति नहीं है।

प्रैक्टिस में, आपके पास ऐसी स्थितियां हो सकती हैं जहां स्थिर डेटा की आवश्यकता हो। यदि अन्य सांख्यिकी के लिए कोई निर्भरता नहीं है, तो स्थिर डेटा const/constexpr बनाएं।

// smart pointer that implements the "Foo" release policy 
class FooPointer 
{ 
    static const FooPointer NullFoo; // does not depend on other static values 
    /* ... */ 
}; 

मामले में स्थैतिक चर एक दूसरे पर निर्भर करते हैं, सिर्फ स्थिर कार्यों में उन्हें लपेट:

// smart pointer that implements the "Foo" release policy 
class FooPointer 
{ 
    static const FooPointer& NullFoo(); // depends on other static values 
    /* ... */ 
}; 

संक्षेप में:

अधिकांश (90% 99%?) स्थैतिक/वैश्विक/साझा डेटा निर्भरता-इंजेक्शन होना चाहिए जहां इसका उपयोग किया जाता है, और स्थिर के रूप में नहीं बनाया गया है।

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

में दुर्लभ मामलों में जब सांख्यिकी को स्थैतिक होने की आवश्यकता होती है और वे एक दूसरे पर निर्भर करते हैं, तो उन्हें स्थिर तरीकों से लपेटें।

अंगूठे के नियम के रूप में, यदि आपके पास दूसरे और तीसरे मामले हैं, तो आप पहले पर्याप्त नहीं कर रहे हैं।