दिलचस्प पोस्ट
मैं अपने एसएसपी.NET अनुप्रयोग में एसक्यूएल इंजेक्शन के हमलों से कैसे बच सकता हूं? मोगोडीबी के साथ उप-दस्तावेज में सरणी कैसे फ़िल्टर करें कैसे numpy में रिकॉर्ड सरणी में सीएसवी को पढ़ने के लिए? सीएसएस छद्म वर्ग या कुछ इसी तरह का स्पर्श करें? अंगुल्य 2 – एप के बाहर के घटक फंक्शन को कैसे कॉल करें वर्चुअल कीबोर्ड एंड्रॉइड पर तब ही टेक्स्ट दृश्य ऊपर ले जाएं एंड्रॉइड – एंड्रॉइड एन पर WebView भाषा अचानक बदलती है किसी विशिष्ट प्रकार (बटन / टेक्स्टबॉक्स) के किसी भी विंडोज फॉर्म के सभी बच्चे नियंत्रण कैसे प्राप्त करें? UITableView पर लंबी दबाएं जावा 8 में नए जावा.पुनर क्यों हैं? जावा 8 में तरीकों से सभी आदिम प्रकारों के लिए अतिभारित नहीं है? सशर्त अभिव्यक्ति के साथ कोणीय एनजी-शैली फ़ोल्डर में सभी फ़ाइलों / फ़ोल्डर को कैसे लें, लेकिन फ़ोल्डर ही नहीं? यह चार क्या है? 65279 '' उत्तरदायी वर्गों की ग्रिड जावा संग्रह सॉर्ट करें

क्यों सी +11 11 में क्लास प्रारंभकर्ता कोष्ठक का उपयोग नहीं कर सकते?

उदाहरण के लिए, मैं यह नहीं लिख सकता हूं:

class A { vector<int> v(12, 1); }; 

मैं केवल यह लिख सकता हूं:

 class A { vector<int> v1{ 12, 1 }; vector<int> v2 = vector<int>(12, 1); }; 

सी ++ 11 भाषा डिजाइन में अंतर के लिए क्या विचार है?

वेब के समाधान से एकत्रित समाधान "क्यों सी +11 11 में क्लास प्रारंभकर्ता कोष्ठक का उपयोग नहीं कर सकते?"

एक संभावित कारण यह है कि कोष्ठकों को अनुमति देने से हमें किसी भी समय सबसे अधिक परेशान करने वाला पार्स वापस ले जाएगा। नीचे दो प्रकारों पर विचार करें:

 struct foo {}; struct bar { bar(foo const&) {} }; 

अब, आपके पास टाइप bar का एक डाटा सदस्य है जिसे आप आरम्भ करना चाहते हैं, इसलिए आप इसे इसे परिभाषित करते हैं

 struct A { bar B(foo()); }; 

लेकिन आपने जो ऊपर किया है, वह B नामक एक समारोह को घोषित करता है जो मान से एक bar ऑब्जेक्ट देता है, और एक एकल तर्क लेता है जो हस्ताक्षर foo() ( foo रिटर्न करता है और कोई आर्गुमेंट नहीं लेता foo() फ़ंक्शन करता है।

नंबर और आवृत्ति प्रश्नों के आधार पर देखते हुए स्टैक ओव्हरफ्लो पर पूछा कि इस समस्या से निपटने के लिए, यह सबसे ज्यादा सी ++ प्रोग्रामर है जो आश्चर्यजनक और अनियंत्रित है नया ब्रेस-या-समान-प्रारंभिक सिंटैक्स जोड़ना इस अस्पष्टता से बचने और क्लीन स्लेट से शुरू करने का एक मौका था, संभवतः सी ++ समिति ने ऐसा करने का कारण चुना है।

 bar B{foo{}}; bar B = foo(); 

उपरोक्त दोनों पंक्तियों को एक प्रकार की B नामक एक ऑब्जेक्ट घोषित किया गया है, जैसा कि अपेक्षित है


उपर्युक्त अनुमान के अलावा, मैं यह कहना चाहूंगा कि आप ऊपर दिए गए उदाहरण में दो बहुत अलग चीजें कर रहे हैं

 vector<int> v1{ 12, 1 }; vector<int> v2 = vector<int>(12, 1); 

पहली पंक्ति एक वेक्टर के लिए v1 को प्रारंभ करती है जिसमें दो तत्व, 12 और 1 । दूसरा एक वेक्टर v2 बनाता है जिसमें 12 तत्व होते हैं, प्रत्येक को 1 आरंभ किया जाता है।

इस नियम के बारे में सावधान रहें – यदि एक प्रकार एक कंस्ट्रक्टर को परिभाषित करता है जो initializer_list<T> लेता है, तो उस कंसट्रक्टर हमेशा हमेशा माना जाता है जब टाइप के लिए प्रारंभकर्ता एक ब्रैकेट-इनिट-सूची होता है अन्य कंस्ट्रक्टरों को केवल तभी माना जाएगा, यदि initializer_list लेते समय व्यवहार्य नहीं होता है।

इस पसंद के पीछे का तर्क स्पष्ट रूप से गैर-स्थिर डेटा सदस्य आरंभकर्ता के लिए संबंधित प्रस्ताव में उल्लिखित है :

पहचानकर्ताओं के दायरे के बारे में कोना में उठाए गए एक मुद्दे:

कोना में सितंबर 2007 की बैठक में कोर वर्किंग ग्रुप में चर्चा के दौरान एक प्रश्न प्रारंभिक रूप में पहचानकर्ताओं के दायरे के बारे में सामने आया। क्या हम आगे की तलाश की संभावना के साथ वर्ग के दायरे को अनुमति देना चाहते हैं; या क्या हम चाहते हैं कि प्रारंभकर्ताओं को उस बिंदु पर अच्छी तरह से परिभाषित किया जाए कि उन्हें पार्स किया जाए?

वांछित क्या है:

कक्षा-स्कोप लुकअप के लिए प्रेरणा यह है कि हम एक गैर-स्टैटिक डेटा सदस्य के प्रारंभिक में कुछ भी डाल सकेंगे, जिसे हम एक मेम-प्रारंभ में डाल सकते हैं बिना शब्दों को बदलकर (मॉड्यूल प्रत्यक्ष प्रारंभिक बनाम कॉपी प्रारंभिकरण) :

 int x(); struct S { int i; S() : i(x()) {} // currently well-formed, uses S::x() // ... static int x(); }; struct T { int i = x(); // should use T::x(), ::x() would be a surprise // ... static int x(); }; 

समस्या 1:

दुर्भाग्यवश, यह "(अभिव्यक्ति सूची)" के आरंभकर्ता बनाता है, उस समय उस समय अस्पष्ट रूप से घोषणा करता है कि घोषणा की जा रही है:

  struct S { int i(x); // data member with initializer // ... static int x; }; struct T { int i(x); // member function declaration // ... typedef int x; }; 

एक संभावित समाधान मौजूदा नियम पर भरोसा करना है, यदि कोई घोषणा किसी ऑब्जेक्ट या फंक्शन हो, तो यह एक फ़ंक्शन है:

  struct S { int i(j); // ill-formed...parsed as a member function, // type j looked up but not found // ... static int j; }; 

एक समान समाधान एक अन्य मौजूदा नियम को लागू करना होगा, जो वर्तमान में केवल टेम्प्लेट में उपयोग किया जाता है, यदि टी एक प्रकार या कुछ और हो सकता है, तो यह कुछ और है; और हम "typename" का उपयोग कर सकते हैं यदि हम वास्तव में एक प्रकार का मतलब है:

 struct S { int i(x); // unabmiguously a data member int j(typename y); // unabmiguously a member function }; 

उन दोनों समाधानों को कई उपयोगकर्ताओं द्वारा गलत तरीके से समझा जा सकता है, (जैसा कि COMP.lang.c++ पर कई प्रश्नों के बारे में बताया गया है कि "int i ();" ब्लॉक स्कोप में एक डिफ़ॉल्ट-प्रारंभिक इंट नहीं घोषित करता है) ।

इस पत्र में प्रस्तावित समाधान "= initializer-clause" और "{initializer-list}" रूपों के प्रारंभकर्ताओं को अनुमति देने के लिए है । यह अधिकांश मामलों में अस्पष्टता की समस्या को हल करता है, उदाहरण के लिए:

 HashingFunction hash_algorithm{"MD5"}; 

यहां, हम = फॉर्म का उपयोग नहीं कर सकते क्योंकि हेजिंग फंक्शन के निर्माता स्पष्ट हैं। विशेष रूप से मुश्किल मामलों में, एक प्रकार का दो बार उल्लेख किया जा सकता है विचार करें:

  vector<int> x = 3; // error: the constructor taking an int is explicit vector<int> x(3); // three elements default-initialized vector<int> x{3}; // one element with the value 3 

उस स्थिति में, हमें उपयुक्त नोटेशन का उपयोग करके दो विकल्पों के बीच चुना जाना चाहिए:

 vector<int> x = vector<int>(3); // rather than vector<int> x(3); vector<int> x{3}; // one element with the value 3 

समस्या 2:

एक और मुद्दा यह है कि, क्योंकि हम स्थिर डेटा सदस्यों को आरंभ करने के लिए नियमों में कोई परिवर्तन नहीं करने का प्रस्ताव देते हैं, स्थिर शब्द जोड़कर एक अच्छी तरह से बनने वाला आरंभकर्ता खराब तरीके से बना सकता है:

  struct S { const int i = f(); // well-formed with forward lookup static const int j = f(); // always ill-formed for statics // ... constexpr static int f() { return 0; } }; 

समस्या 3:

तीसरी समस्या यह है कि क्लास-स्कोप लुकअप रन-टाइम त्रुटि में एक संकलन-समय त्रुटि को चालू कर सकता है:

 struct S { int i = j; // ill-formed without forward lookup, undefined behavior with int j = 3; }; 

(जब तक कम्पाइलर द्वारा पकड़ा नहीं गया हो, मुझे जम्मू के अपरिभाषित मान के साथ intialized किया जा सकता है।)

प्रस्ताव:

सीडब्ल्यूजी में कक्षा-स्कोप देखने के पक्ष में कोना में 6 से 3 स्ट्रॉ पोल था; और यह वही है जो इस पत्र का प्रस्ताव है, "नॉन-स्टैटिक डेटा सदस्यों के लिए इनिशलाइजर्स के साथ" = आरंभिक-खंड "और" {initializer-list} "रूपों तक सीमित है।

हमें यकीन है:

समस्या 1: यह समस्या उत्पन्न नहीं होती क्योंकि हम () नोटेशन का प्रस्ताव नहीं करते हैं = और {} प्रारंभिक नोटेशन इस समस्या से ग्रस्त नहीं हैं

समस्या 2: स्थिर कीवर्ड जोड़ने से कई अंतर हो सकते हैं, यह उनमें से कम से कम है

समस्या 3: यह एक नई समस्या नहीं है, लेकिन पहले से ही कन्स्ट्रक्टर इनेक्टर्सर्स के साथ मौजूद होने वाली एक ही क्रम-की-प्रारंभिक समस्या है।