वर्दी प्रारंभिक खतरनाक का उपयोग नहीं कर रहा है?

Question

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

हालांकि, मैं सोच इस नए वाक्य रचना अधिक परेशानी है कि तुलना में यह लायक है मदद नहीं कर सकता ...

---

पहले उदाहरण

मैं एक पुस्तकालय, जिसमें मेरे पास लिखने मान लीजिए इस तरह की एक struct:

struct MyStruct 
{ 
    int member0; 
    int member1; 
} 

एक उपयोगकर्ता इस का उपयोग करते हुए कुल प्रारंभ की तरह कुछ लिख सकते हैं:

MyStruct myVar = {0, 1}; // member0 = 0 and member1 = 1 

अब, हम कहते हैं कि मैं अपने पुस्तकालय अपडेट करने दें, और struct अब इस तरह दिखता है कि:

struct MyStruct 
{ 
    int member0; 
    int member1; 

    MyStruct(int p0, int p1) : member0(p1), member1(p0){} 
} 

से पहले सी ++ 11, संकलन बंद कर देंगे उपयोगकर्ता कोड है, जो मजबूर होना पड़ा उपयोगकर्ता अपने कोड को फिर से लिखने और कन्स्ट्रक्टर का उपयोग करने के लिए। लेकिन अब, कोड संकलन होगा और वर्दी प्रारंभ के रूप में व्याख्या की जा:

MyStruct myVar = {0, 1}; // member0 = 1 and member1 = 0 

उपयोगकर्ता बिना जानते हुए भी, अपने पुस्तकालय को अद्यतन करने के लिए अपने कोड कर देगा बहुत अलग कुछ करना!

class MyClass 
{ 
public: 
    MyClass(int size, int default = 0) : elements(size, default){} 
private: 
    std::vector<int> elements; 
} 

एक उपयोगकर्ता इसे इस तरह उपयोग कर सकते हैं:

MyClass myVar (3,1); // 3 elements with value 1 

---

दूसरा उदाहरण

अब, हम कहते हैं कि मैं अपने पुस्तकालय में इस तरह एक वर्ग डालते हैं

या, वर्दी initilization का उपयोग कर, इस तरह:

MyClass myVar {3,1}; // 3 elements with value 1 

फिर, हम कहें कि मैं अपनी लाइब्रेरी अपडेट करता हूं। वर्ग अब इस तरह दिखना:

class MyClass 
{ 
public: 
    MyClass(int size, int default = 0) : elements(size, default){} 
    MyClass(std::initializer_list<int> elts) : elements(elts){} 
private: 
    std::vector<int> elements; 
} 

कोई समस्या हो नहीं होगा अगर एक क्लासिक निर्माता इस्तेमाल किया गया था:

MyClass myVar (3,1); // 3 elements with value 1 

लेकिन कोड व्याख्या बदल जाएगा यदि वर्दी प्रारंभ बुलाया गया था:

MyClass myVar {3,1}; // 2 elements with values 3 and 1 

---

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

इससे भी बदतर, वर्दी प्रारंभिक परिचय की शुरुआत कुल प्रारंभिक खतरनाक के रूप में होती है।

क्या मुझे कुछ याद आया है? क्या कोई संदर्भ है जिसमें वर्दी प्रारंभिकता का उपयोग सुरक्षित और उपयोगी दोनों है?

Answer 1

मुझे लगता है कि आपके द्वारा संबोधित दोनों समस्याओं को समान प्रारंभिकता के साथ बहुत कम करना है, लेकिन एक इंटरफ़ेस बदलने के खतरों को चित्रित करें।

आप इस तरह अपने पुस्तकालय को अपडेट करके उन कोड में बहुत ही इनकी परिवर्तन को संग्रहीत कर सकते हैं:

struct MyStruct 
{ 
    int member1; 
    int member0; 
} 

कोई वर्दी प्रारंभ involed।

class some_class 
{ 
    public: 
    some_class(int); 
} 

उपयोगकर्ता सांकेतिक शब्दों में बदलनेवाला:: यह भी निर्माता अधिभार संकल्प द्वारा चुना बदलना संभव, पूर्व C++ 11, था

class some_class 
{ 
    public: 
    some_class(int); 
    some_class(double); 
} 

:

some_class var(1.0); 

कोड करने के लिए बदल रहे थे, तो

दूसरा कन्स्ट्रक्टर कहा जाएगा। फिर, कोई समान प्रारंभिक शामिल नहीं था, फिर भी वही समस्याएं होती हैं।

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

contray पर, वर्दी प्रारंभिक कुछ वास्तविक फायदे प्रदान करता है। उन लोगों के लिए, यह excellent answer