दिलचस्प पोस्ट
PHP – अगर / के लिए, के लिए, foreach, जबकि – घुंघराले ब्रेसिज़ के बिना? यूज़रनेक्शन के लिए कस्टम इन्टेशन दृश्य मैप्यूव्यू नहीं चल रहा है कैसे प्रति समूह अवलोकनों को जोड़ने और ggplot2 boxplot में समूह का उपयोग करने के लिए? मैं UIanimationtransitioncurl का उपयोग करके छवि को एनीमेशन का उपयोग करना चाहता हूं, सही या बाएं क्या यह संभव है? C ++ 11 चालन निर्माता नहीं कहा जाता है, डिफ़ॉल्ट कन्स्ट्रक्टर पसंदीदा है एकाधिक क्षेत्रों पर एमवीसी फॉर्म सत्यापन किसी MongoDB डेटाबेस में सब कुछ हटाएं जावास्क्रिप्ट एरे ब्रेसिज़ बनाम ब्रैकेट्स कैसे एक div तत्व करने के लिए onload घटना जोड़ने के लिए? आप सी में एक फ़ाइल के आकार का निर्धारण कैसे करते हैं? स्विफ्ट में स्ट्रिंग में इंट को परिवर्तित करें "शाखा" से हमारा क्या मतलब है? ब्रॉडकास्ट रिसीवर का उपयोग करके ब्लूटूथ स्टेटस का पता लगाने के लिए कैसे? क्या PHP में सरणी का उपयोग करना ठीक है? जावास्क्रिप्ट में, शून्य को शून्य रिटर्न NaN से विभाजित क्यों किया जाता है, लेकिन शून्य रिटर्न इन्फिनिटी से विभाजित किसी भी अन्य को?

shared_ptr संदर्भ या मूल्य से?

जब फ़ंक्शन को shared_ptr (बूस्ट या सी ++ 11 एसटीएल से) लेना चाहिए, तो क्या आप इसे पास कर रहे हैं?

मैं पहली पद्धति को पसंद करता हूं क्योंकि मुझे संदेह है कि यह तेजी से होगा लेकिन क्या यह वास्तव में एक मूल्य है या क्या कोई अतिरिक्त मुद्दे हैं?

क्या आप कृपया अपनी पसंद के कारण दे सकते हैं या यदि मामला है, तो आपको क्यों लगता है कि इससे कोई फर्क नहीं पड़ता

Solutions Collecting From Web of "shared_ptr संदर्भ या मूल्य से?"

इस सवाल पर चर्चा की गई है और स्कॉट, आंद्रेई और हर्ब ने हमें सी ++ और 2011 से परे कुछ भी सत्र के दौरान पूछे जाने पर उत्तर दिया है । 4min 34sec से shared_ptr प्रदर्शन और शुद्धता पर देखें ।

थोड़े समय तक, मूल्य से पारित करने का कोई कारण नहीं है , जब तक कि बहु-थ्रेडिंग चालू न हो, लेकिन इसे अलग से विचार किया जाना चाहिए

जब तक आप इसके ऊपर लिखित बात वीडियो में स्कॉट मेयेर्स द्वारा बताए गए अनुसार इसे स्थानांतरित नहीं कर सकते, लेकिन यह आपके द्वारा उपयोग किए जा सकने वाले सी ++ के वास्तविक संस्करण से संबंधित है।

इस चर्चा के लिए एक प्रमुख अद्यतन GoingNative 2012 सम्मेलन के इंटरएक्टिव पैनल के दौरान हुआ है : हमें कुछ भी पूछो! जो देखने योग्य है, खासकर 22:50 से ।

निजी तौर पर मैं एक const संदर्भ का प्रयोग करूँगा। फ़ंक्शन कॉल के लिए फिर से इसे कम करने के लिए संदर्भ संख्या में वृद्धि करने की कोई आवश्यकता नहीं है।

यहाँ जड़ी बूटी Sutter लेना है

दिशानिर्देश: एक स्मार्ट पॉइंटर को फ़ंक्शन पैरामीटर के रूप में न दें, जब तक कि आप स्मार्ट पॉइंटर का उपयोग या हेरफेर करना न करें, जैसे कि साझा करने या स्वामित्व स्थानांतरित करना।

दिशानिर्देश: व्यक्त करें कि एक फ़ंक्शन साझा किए गए ऑप्शन का स्वामित्व एक बाय-मूल्य share_ptr पैरामीटर का उपयोग करके साझा करेगा और साझा करेगा।

दिशानिर्देश: केवल एक साझा-आईपीटीआर को संशोधित करने के लिए गैर-कॉन्स्ट शेअर्ड आईपीटी और पैरामीटर का प्रयोग करें। एक const share_ptr और एक पैरामीटर के रूप में केवल तभी उपयोग करें जब आपको यह सुनिश्चित न हो कि आप एक प्रति ले लेंगे और स्वामित्व साझा करेंगे या नहीं; अन्यथा इसके बजाय विजेट का उपयोग करें (या यदि नहीं है, तो विजेट और)

const संदर्भ से पास करें, यह तेज़ है यदि आपको इसे स्टोर करने की आवश्यकता है, तो कुछ कंटेनर में, रेफरी में कहें। प्रतिलिपि ऑपरेशन द्वारा गिनती स्वचालित रूप से बढ़ी जाएगी।

मैंने नीचे कोड चलाया, एक बार foo को shared_ptr द्वारा एक और साथ में फिर और फिर foo को shared_ptr मूल्य द्वारा shared_ptr किया जाता है।

 void foo(const std::shared_ptr<int>& p) { static int x = 0; *p = ++x; } int main() { auto p = std::make_shared<int>(); auto start = clock(); for (int i = 0; i < 10000000; ++i) { foo(p); } std::cout << "Took " << clock() - start << " ms" << std::endl; } 

वीएस2015 का उपयोग करना, मेरे इंटेल कोर 2 क्वाड (2.4GHz) प्रोसेसर पर एक्स 86 रिलीज बिल्ड

 const shared_ptr& - 10ms shared_ptr - 281ms 

मूल्य संस्करण द्वारा प्रतिलिपि परिमाण के क्रम धीमी थी।
यदि आप मौजूदा थ्रेड से समन्वयित फ़ंक्शन बुला रहे हैं, तो const& version को पसंद करें।

चूंकि सी ++11 आपको इसे मान से अधिक और अधिक बार सोचने से ज्यादा मूल्य लेना चाहिए।

यदि आप std :: shared_ptr (बजाय अंतर्निहित प्रकार टी के बजाय) ले रहे हैं, तो आप ऐसा इसलिए कर रहे हैं क्योंकि आप इसके साथ कुछ करना चाहते हैं।

यदि आप इसे कहीं कॉपी करना चाहते हैं, तो इसे प्रतिलिपि बनाने के लिए और अधिक समझ में आता है, और std :: इसे आंतरिक रूप से स्थानांतरित करने के बजाय const और इसे बाद में प्रतिलिपि बनाने की बजाय। इसका कारण यह है कि आप कॉल करने वाले विकल्प को बदले में std :: को अपने फ़ंक्शन को कॉल करते समय साझा किया जाता है, इस तरह खुद को वेतन वृद्धि और घटाव कार्यों का एक सेट बचाता है। या नहीं। यही है, फ़ंक्शन के कॉलर यह तय कर सकता है कि फ़ंक्शन को बुलाए जाने के बाद स्टड :: साझा एपीटीआर की जरूरत है या नहीं, और उसके आधार पर कि क्या चल रहा है या नहीं या नहीं। यदि आप const & द्वारा पास करते हैं तो यह प्राप्त नहीं हो सकता है, और इस प्रकार यह मूल्य द्वारा इसे लेने के लिए प्राथमिकता है।

बेशक, यदि कॉलर दोनों को अपने साझा_पीटीआर को अधिक समय के लिए चाहिए (इस प्रकार std :: इसे स्थानांतरित नहीं कर सकते हैं) और आप फ़ंक्शन में एक सादे प्रतिलिपि नहीं बनाना चाहते हैं (कहते हैं कि आप एक कमजोर सूचक चाहते हैं, या आप कभी-कभी चाहते हैं इसे कॉपी करने के लिए, कुछ शर्त के आधार पर), फिर एक const और अभी भी बेहतर हो सकता है

उदाहरण के लिए, आपको करना चाहिए

 void enqueue(std::shared<T> t) m_internal_queue.enqueue(std::move(t)); 

ऊपर

 void enqueue(std::shared<T> const& t) m_internal_queue.enqueue(t); 

क्योंकि इस मामले में आप हमेशा प्रतिलिपि आंतरिक रूप से बनाते हैं

Share_copy प्रतिलिपि ऑपरेशन की समय लागत नहीं जानती, जहां परमाणु वृद्धि और घटते समय में, मुझे बहुत अधिक CPU उपयोग की समस्या से सामना करना पड़ा। मुझे कभी उम्मीद नहीं थी कि परमाणु वृद्धि और घटती लागत बहुत अधिक लग सकती है

मेरे परीक्षण के परिणाम के बाद, अंतर 32 परमाणु वृद्धि और कमी को गैर-परमाणु वृद्धि और घटने से 2 या 40 बार लग जाता है। मुझे विंडोज 8.1 के साथ 3 जीएचएस कोर आई 7 पर मिला। पूर्व का नतीजा तब होता है जब कोई विवाद नहीं होता है, जब उत्तरार्ध में विवाद की उच्च संभावना होती है। मुझे ध्यान में रखना है कि परमाणु आपरेशन पिछले हार्डवेयर आधारित लॉक पर हैं लॉक लॉक है विवाद होने पर प्रदर्शन के लिए खराब

यह अनुभव करते हुए, मैं हमेशा byval (share_ptr) और byval (shared_ptr) की तुलना में byref का उपयोग करता हूँ

साझा एपीटीआर काफी बड़ा नहीं है, न ही इसके कन्स्ट्रक्टर \ डिस्ट्रिक्टर को प्रतिलिपि बनाने के लिए पर्याप्त काम करने के लिए कॉपी बनाकर संदर्भ बनाम पास द्वारा पास के बारे में ध्यान देने के लिए पर्याप्त काम करना है।