दिलचस्प पोस्ट
Ggplot2 के लिए मैन्युअल रूप से समूह रंग सेट करना अजगर का उपयोग करके एक सरल XML फ़ाइल बनाना PYTHONPATH का उपयोग कैसे करें दूसरा सबसे बड़ा मूल्य खोजने के लिए सरल एसक्यूएल क्वेरी क्या है? सी प्रोग्रामिंग में Fflush (stdin) का उपयोग क्या है ट्यूपल्स में अस्थिर वस्तुओं क्यों हो सकते हैं? Android 4.4.2 में Google API (x86 सिस्टम छवि) और Google API (एआरएम सिस्टम छवि) के बीच का अंतर क्या जावा में बफर ओवरफ्लो है? आप फ़ंक्शन के बजाय एक्सपेन <Func <T >> का उपयोग क्यों करेंगे? जीएसएक्स फेंकता है MalformedJsonException मिश्रित मोड विधानसभा.नेट 4 में एकाधिक खोज स्ट्रिंग के साथ MySQL find_in_set मैं जावास्क्रिप्ट में एक यूआरएल क्वेरी मापदंड कैसे पार्स हूं? jQuery स्लाइड बाएं और दिखाएं पायथन में फ़ंक्शन से मैं दो मान कैसे वापस कर सकता हूँ?

ब्रेस-संलग्न प्रारंभकर्ता का उपयोग कब किया जाए?

सी ++ 11 में, हमारे पास उस कक्षा को प्रारंभ करने के लिए नया सिंटैक्स है जो हमें बड़ी संख्या में संभावनाएं प्रदान करता है कि कैसे चर को इनिशियलाइज़ करना है

{ // Example 1 int b(1); int a{1}; int c = 1; int d = {1}; } { // Example 2 std::complex<double> b(3,4); std::complex<double> a{3,4}; std::complex<double> c = {3,4}; auto d = std::complex<double>(3,4); auto e = std::complex<double>{3,4}; } { // Example 3 std::string a(3,'x'); std::string b{3,'x'}; // oops } { // Example 4 std::function<int(int,int)> a(std::plus<int>()); std::function<int(int,int)> b{std::plus<int>()}; } { // Example 5 std::unique_ptr<int> a(new int(5)); std::unique_ptr<int> b{new int(5)}; } { // Example 6 std::locale::global(std::locale("")); // copied from 22.4.8.3 std::locale::global(std::locale{""}); } { // Example 7 std::default_random_engine a {}; // Stroustrup's FAQ std::default_random_engine b; } { // Example 8 duration<long> a = 5; // Stroustrup's FAQ too duration<long> b(5); duration<long> c {5}; } 

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

जब यह टेम्पलेट कोड की बात आती है, तो वाक्यविन्यास को बदलने से अलग अर्थ हो सकते हैं, इसलिए सही तरीके से चलना आवश्यक है।

मुझे आश्चर्य है कि क्या एक सार्वभौमिक दिशानिर्देश है, जो वाक्यविन्यास को एक को चुना जाना चाहिए।

वेब के समाधान से एकत्रित समाधान "ब्रेस-संलग्न प्रारंभकर्ता का उपयोग कब किया जाए?"

मुझे लगता है कि निम्नलिखित एक अच्छी दिशानिर्देश हो सकती हैं:

  • यदि आप (एकल) मूल्य के साथ आरंभ कर रहे हैं वस्तु का सही मूल्य होने का इरादा है, तो प्रतिलिपि ( = ) आरंभीकरण का उपयोग करें (क्योंकि तब त्रुटि के मामले में, आप कभी भी स्पष्ट रूप से एक स्पष्ट रचनाकार नहीं करेंगे, जो आम तौर पर प्रदान की गई व्याख्या मूल्य अलग तरह से)। ऐसी जगहों पर जहां प्रतिलिपि उपलब्ध नहीं है, देखें कि ब्रेस आरंभीकरण सही शब्दों का है, और यदि ऐसा है, तो इसका उपयोग करें; अन्यथा कोष्ठक आरंभीकरण का उपयोग करें (यदि वह भी उपलब्ध नहीं है, तो आप वैसे भी भाग्य से बाहर हैं)।

  • यदि आप जिन मूल्यों को आरंभ कर रहे हैं , वे ऑब्जेक्ट (जैसे वेक्टर / एरे के तत्वों, या एक जटिल संख्या के वास्तविक / काल्पनिक भाग) में संग्रहीत किए जाने वाले मानों की एक सूची हैं, यदि उपलब्ध है तो घुंघराले ब्रेसिज़ आरंभीकरण का उपयोग करें।

  • यदि आप जिन मूल्यों को आरंभ कर रहे हैं वे संग्रहीत किए जाने वाले मान नहीं हैं, लेकिन ऑब्जेक्ट के इच्छित मान / स्थिति का वर्णन करें, कोष्ठक का उपयोग करें। उदाहरण एक vector के आकार तर्क या एक fstream के फ़ाइल नाम तर्क हैं।

मुझे पूरा यकीन है कि कभी भी सार्वभौमिक दिशानिर्देश नहीं होगा। मेरा दृष्टिकोण हमेशा याद रखना है कि कुरकुरा ब्रेसिज़ का प्रयोग करना

  1. Initializer सूची कंसल्टेंट्स अन्य कंसल्टेंट्स पर पूर्वता ले
  2. सभी मानक पुस्तकालय कंटेनरों और std :: basic_string के initializer सूची कन्स्ट्रक्टर हैं।
  3. घुंघराले ब्रेस आरंभीकरण संकीर्ण रूपांतरण की अनुमति नहीं देता है।

तो गोल और कर्ली ब्रेसिज़ विनिमेय नहीं हैं लेकिन यह जानने के लिए कि वे कहां भिन्न हैं, मुझे अधिकतर मामलों में घुमावदार दौर का उपयोग करने की अनुमति देता है (कुछ ऐसे मामले जिनमें मैं वर्तमान में संकलक कीड़े नहीं कर सकता)

सामान्य कोड (यानी टेम्पलेट्स) के बाहर, आप (और मैं) हर जगह ब्रेसिज़ का उपयोग कर सकते हैं एक फायदा यह है कि यह हर जगह काम करता है, उदाहरण के लिए यहां तक ​​कि क्लास के प्रारंभ में भी:

 struct foo { // Ok std::string a = { "foo" }; // Also ok std::string b { "bar" }; // Not possible std::string c("qux"); // For completeness this is possible std::string d = "baz"; }; 

या फ़ंक्शन तर्कों के लिए:

 void foo(std::pair<int, double*>); foo({ 42, nullptr }); // Not possible with parentheses without spelling out the type: foo(std::pair<int, double*>(42, nullptr)); 

चर के लिए मैं T t = { init }; बीच ज्यादा ध्यान नहीं देता T t = { init }; या T t { init }; शैलियों, मुझे नाबालिग होने के लिए अंतर मिल रहा है और खराब होने पर केवल एक उपयोगी कंपाइलर संदेश के परिणामस्वरूप एक explicit निर्माता का दुरुपयोग किया जा सकता है

ऐसे प्रकार के लिए, जो std::initializer_list स्वीकार करते हैं हालांकि जाहिर है कि कभी-कभी गैर- std::initializer_list निर्माणकों की आवश्यकता होती है (क्लासिक उदाहरण, std::vector<int> twenty_answers(20, 42); )। तो ब्रेसिज़ का उपयोग नहीं करना ठीक है।


जब यह जेनेरिक कोड (जैसे टेम्पलेट्स) की बात आती है, तो बहुत अंतिम पैराग्राफ को कुछ चेतावनियां उठानी चाहिए। निम्नलिखित को धयान मे रखते हुए:

 template<typename T, typename... Args> std::unique_ptr<T> make_unique(Args&&... args) { return std::unique_ptr<T> { new T { std::forward<Args>(args)... } }; } 

फिर auto p = make_unique<std::vector<T>>(20, T {}); T 2 आकार के एक सदिश बनाता है यदि T , उदाहरण के लिए है int , या आकार का एक सदिश 20 यदि T std::string । एक बहुत ही चतुर संकेत है कि यहाँ पर कुछ गड़बड़ कुछ है जो आपको यहां बचा सकता है (उदाहरण के लिए std::is_constructible साथ): std::is_constructible प्रत्यक्ष-प्रारंभ के संदर्भ में है, जबकि हम std::is_constructible -आरंभीकरण का उपयोग कर रहे हैं सीधे- initialization करने के लिए defers अगर और अगर वहाँ कोई निर्माता std::initializer_list interfering ले रही है। इसी तरह std::is_convertible कोई मदद नहीं है।

मैंने जांच की है कि वास्तव में यह संभव है कि उस गुण को ठीक कर सकता है जो कि ठीक कर सकता है लेकिन मैं इस बारे में अधिक आशावादी नहीं हूं। किसी भी स्थिति में मुझे नहीं लगता कि हम बहुत ज्यादा याद करेंगे, मुझे लगता है कि तथ्य यह है कि make_unique<T>(foo, bar) T(foo, bar) बराबर एक निर्माण में परिणाम बहुत सहज है; विशेष रूप से दिया गया है कि make_unique<T>({ foo, bar }) काफी भिन्न है और केवल तभी समझ में आता है अगर foo और bar एक ही प्रकार से होते हैं।

इसलिए जेनेरिक कोड के लिए मैं केवल मूल्य आरंभीकरण (जैसे T t {}; या T t = {}; लिए ब्रेसेज़ का उपयोग करता हूं , जो बहुत सुविधाजनक है और मुझे लगता है कि सी ++ 03 से बेहतर T t = T();अन्यथा यह या तो प्रत्यक्ष प्रारंभिक वाक्यविन्यास (यानी T t(a0, a1, a2); ), या कभी-कभी डिफ़ॉल्ट निर्माण ( T t; stream >> t; केवल एक ऐसा मामला है जहां मुझे लगता है कि मुझे लगता है)

इसका मतलब यह नहीं है कि सभी ब्रेसिज़ खराब हैं, हालांकि फिक्स के साथ पिछले उदाहरण पर विचार करें:

 template<typename T, typename... Args> std::unique_ptr<T> make_unique(Args&&... args) { return std::unique_ptr<T> { new T(std::forward<Args>(args)...) }; } 

यह अभी भी std::unique_ptr<T> के निर्माण के लिए ब्रेसिज़ का उपयोग करता है, भले ही वास्तविक प्रकार टेम्प्लेट पैरामीटर T पर निर्भर करता है।