C ++ में, वैक्टर पर सूचियों का उपयोग करने का क्या मतलब है?

Question

मैंने C ++ सूचियों और वैक्टर से जुड़े 3 अलग-अलग प्रयोग किए हैं।

वेक्टर के साथ वे अधिक कुशल साबित हुए, जब बीच में बहुत सारे सम्मिलन शामिल थे।

इसलिए सवाल: किस मामले में सूचियां वैक्टर से ज्यादा मायने रखती हैं?

यदि वैक्टर अधिकांश मामलों में अधिक कुशल लगते हैं, और यह विचार करते हुए कि उनके सदस्य एक जैसे हैं, तो सूचियों के लिए कौन से लाभ शेष हैं?

1. एन पूर्णांक उत्पन्न करें और उन्हें एक कंटेनर में रखें ताकि कंटेनर को छंटनी बनी रहे। सम्मिलन भोलेपन से किया गया है, तत्वों को एक-एक करके पढ़ना और पहले बड़े से पहले एक नया डालना।
   एक सूची के साथ, समय छत से गुजरता है जब वैक्टर की तुलना में आयाम बढ़ता है।

2. कंटेनर के अंत में एन पूर्णांक डालें।
   सूचियों और वैक्टर के लिए, परिमाण के समान क्रम से समय बढ़ा, हालांकि यह वैक्टर के साथ 3 गुना तेज था।

3. एक कंटेनर में एन पूर्णांक डालें।
   टाइमर प्रारंभ करें।
   सूचियों के लिए list.sort का उपयोग करके कंटेनर को सॉर्ट करें और वैक्टर के लिए std :: सॉर्ट करें। टाइमर बंद करो।
   फिर से, परिमाण के उसी क्रम से समय बढ़ता है, लेकिन यह वैक्टर के साथ औसतन 5 गुना तेज है।

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

लेकिन इस संदेश को पढ़ने वाले आप लोगों का संयुक्त अनुभव अधिक उत्पादक उत्तर प्रदान कर सकता है।

आप उन स्थितियों में आ सकते हैं जहाँ सूचियों का उपयोग करना अधिक सुविधाजनक था, या बेहतर प्रदर्शन किया?

Comments

आपको किसी सरणी / सरणी सूची में लिंक की गई सूची का उपयोग कब करना चाहिए ? यदि आप पहले से ही हैं

— कार्तिक टी।

यहाँ इस विषय पर एक और अच्छा संसाधन है: stackoverflow.com/a/2209564/8360 भी, अधिकांश सी ++ मार्गदर्शन मैंने सुना है कि डिफ़ॉल्ट रूप से वेक्टर का उपयोग करना है, केवल तभी यदि आपके पास कोई विशिष्ट कारण है।

— Zachary Yates

धन्यवाद। हालाँकि मैं पसंदीदा उत्तर में कही गई बातों से सहमत नहीं हूँ। इन प्रयोगों में से अधिकांश को मेरे प्रयोगों द्वारा अमान्य कर दिया गया है। इस व्यक्ति ने किताबों या स्कूल में पढ़ाए गए किसी भी परीक्षण और व्यापक सिद्धांत को लागू नहीं किया है।

— मारेक स्टेनली

एक listअगर आप तत्वों के बहुत सारे हटा रहे हैं शायद बेहतर है। मुझे विश्वास नहीं है कि vectorकभी भी सिस्टम में मेमोरी वापस आएगी जब तक कि पूरे वेक्टर को हटा नहीं दिया जाता। यह भी ध्यान रखें कि आपका परीक्षण # 1 सम्मिलन समय का परीक्षण नहीं कर रहा है। यह खोज और सम्मिलन के संयोजन की एक परीक्षा है। यह उस जगह को खोजने के लिए है जहां listधीमा है। वास्तविक आवेषण वेक्टर की तुलना में तेज़ होगा।

— रोबोट

यह इतना विशिष्ट है कि यह प्रश्न (रन टाइम) प्रदर्शन, प्रदर्शन और केवल प्रदर्शन के संदर्भ में वर्णित है। यह बहुत सारे प्रोग्रामर का एक अंधा स्थान प्रतीत होता है - वे इस पहलू पर ध्यान केंद्रित करते हैं और यह भूल जाते हैं कि दर्जनों अन्य पहलू हैं जो अक्सर बहुत अधिक महत्वपूर्ण होते हैं।

— Doc Brown

Answer 1

संक्षिप्त उत्तर यह है कि मामले कम और दूर के लगते हैं। वहाँ शायद कुछ कर रहे हैं।

एक तब होगा जब आपको बड़ी संख्या में बड़ी वस्तुओं को संग्रहीत करने की आवश्यकता होगी - विशेष रूप से, ऐसी वस्तुएँ जो इतनी बड़ी हैं कि उनमें से कुछ अतिरिक्त के लिए स्थान आवंटित करना अव्यावहारिक है। मूल रूप से एक वेक्टर या अतिरिक्त वस्तुओं के लिए जगह आवंटित करने से रोकने के लिए कोई रास्ता नहीं है - यह है कि उन्हें कैसे परिभाषित किया जाता है (यानी, उन्हें अपनी जटिलता आवश्यकताओं को पूरा करने के लिए अतिरिक्त स्थान आवंटित करना होगा )। यदि आप फ्लैट-आउट की अनुमति नहीं दे सकते हैं तो अतिरिक्त स्थान आवंटित किया std::listजा सकता है, यह एकमात्र मानक कंटेनर हो सकता है जो आपकी आवश्यकताओं को पूरा करता है।

एक और होगा जब / यदि आप एक सूची में "रोचक" बिंदु के लिए एक समय के लिए एक विस्तारित अवधि के लिए एक पुनरावृत्ति स्टोर करेंगे, और जब आप सम्मिलन और / या विलोपन करते हैं, तो आप (लगभग) हमेशा इसे एक स्पॉट से करते हैं जिसमें आपके पास पहले से ही एक पुनरावृत्ति है, इसलिए आप उस बिंदु तक पहुंचने के लिए सूची से नहीं चलते हैं जहां आप प्रविष्टि या विलोपन करने जा रहे हैं। यदि आप एक से अधिक स्थानों के साथ काम करते हैं, तो स्पष्ट रूप से वही लागू होता है, लेकिन फिर भी प्रत्येक स्थान पर एक पुनरावृत्ति स्टोर करने की योजना बनाते हैं, जिसके साथ आप काम करने की संभावना रखते हैं, इसलिए आप सबसे अधिक हेरफेर करने वाले स्पॉट तक सीधे पहुंच सकते हैं, और केवल शायद ही कभी सूची के माध्यम से चलें। उन स्थानों के लिए।

पहले उदाहरण के लिए, वेब ब्राउज़र पर विचार करें। यह Tabऑब्जेक्ट की एक लिंक की गई सूची को रख सकता है , जिसमें ब्राउज़र में खुले टैब पर प्रत्येक टैब ऑब्जेक्ट का प्रतिनिधित्व होता है। प्रत्येक टैब कुछ दर्जन मेगाबाइट डेटा हो सकता है (अधिक, विशेषकर यदि कोई वीडियो शामिल है जैसे)। खुले टैब की आपकी विशिष्ट संख्या आसानी से एक दर्जन से कम हो सकती है, और 100 शायद ऊपरी चरम के करीब है।

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

एक समय में एक बार (वैश्विक खोज और प्रतिस्थापित जैसी चीजें) आप सभी सूचियों में सभी वस्तुओं के माध्यम से चलना समाप्त कर देते हैं, लेकिन यह काफी असामान्य है, और जब आप करते हैं, तो आप संभवतः एक आइटम के भीतर खोज करने के लिए पर्याप्त काम करने जा रहे हैं। सूची, कि सूची को पार करने का समय लगभग असंगत है।

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

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

Comments

+1, लेकिन: पहला मामला गायब हो जाता है जब आप पॉइंटर्स का उपयोग करते हैं, जिसे आपको हमेशा बड़ी वस्तुओं के साथ उपयोग करना चाहिए। लिंक की गई सूचियाँ दूसरे के उदाहरण के लिए उपयुक्त नहीं हैं; जब वे कम हों तो सभी ऑपरेशनों के लिए खुद को गिरफ्तार कर लेते हैं।

— अमारा

बड़ी वस्तु का मामला बिल्कुल भी काम नहीं करता है। std::vectorपॉइंटर्स का उपयोग करना अधिक कुशल होगा, फिर उन सभी लिंक्ड लिस्ट नोड ऑब्जेक्ट्स।

— विंस्टन एवरर्ट

लिंक की गई सूचियों के लिए कई उपयोग हैं - यह सिर्फ इतना है कि वे गतिशील सरणियों के रूप में आम नहीं हैं। एक LRU कैश एक लिंक्ड सूची का एक सामान्य उपयोग है।

— चार्ल्स साल्विया

इसके अलावा, एक std::vector<std::unique_ptr<T>>अच्छा विकल्प हो सकता है।

— Deduplicator

Answer 2

खुद बज़्ने स्ट्रॉस्ट्रुप के अनुसार, डेटा के अनुक्रमों के लिए वैक्टर हमेशा डिफ़ॉल्ट संग्रह होना चाहिए। आप सूची चुन सकते हैं यदि आप तत्वों के सम्मिलन और विलोपन के लिए अनुकूलन करना चाहते हैं, लेकिन आम तौर पर आपको नहीं करना चाहिए। सूची की लागत धीमी गति से बढ़ने और स्मृति उपयोग है।

वह इस प्रस्तुति में इस बारे में बात करते हैं ।

लगभग 0:44 पर वे वैक्टर बनाम सूचियों के बारे में बात करते हैं।

संकुचितता मायने रखती है। वैक्टर सूचियों की तुलना में अधिक कॉम्पैक्ट हैं। और पूर्वानुमान योग्य उपयोग पैटर्न बहुत मायने रखता है। वैक्टर के साथ आपको कई तत्वों को खत्म करना होगा लेकिन कैश वास्तव में बहुत अच्छे हैं। ... सूचियों में यादृच्छिक पहुँच नहीं है। लेकिन जब आप किसी सूची को आगे बढ़ाते हैं, तो आप रैंडम एक्सेस करते रहते हैं। यहाँ एक नोड है, और यह उस नोड में जाता है, स्मृति में। तो आप वास्तव में अपनी मेमोरी को रैंडम एक्सेस कर रहे हैं, और आप अपने कैश मिस को अधिकतम कर रहे हैं, जो कि आप जो चाहते हैं उसके बिल्कुल विपरीत है।

लगभग 1:08 पर, उन्हें इस मुद्दे के बारे में एक सवाल दिया जाता है।

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

Comments

क्या आप संक्षेप में लिखेंगे कि प्रस्तुति में आपको "0:44 और 1:08" के बारे में क्या कहा गया है ?

— gnat

@ नागट - निश्चित रूप से। मैंने उस सामान को उद्धृत करने की कोशिश की है जो अलग से समझ में आता है, और जिसे स्लाइड के संदर्भ की आवश्यकता होती है।

— पीट

Answer 3

एकमात्र स्थान जहां मैं आमतौर पर सूचियों का उपयोग करता हूं, जहां मुझे तत्वों को मिटाने और पुनरावृत्तियों को अमान्य नहीं करने की आवश्यकता होती है। std::vectorसम्मिलित करने और मिटाने पर सभी पुनरावृत्तियों को अमान्य करता है। std::listयह गारंटी देता है कि मौजूदा तत्वों में पुनरावृत्तियाँ सम्मिलित या हटाने के बाद भी मान्य हैं।

Answer 4

पहले से उपलब्ध कराए गए अन्य उत्तरों के अलावा, सूचियों में कुछ विशेषताएं हैं जो वैक्टर में मौजूद नहीं हैं (क्योंकि वे बहुत महंगे होंगे।) सबसे महत्वपूर्ण होने के नाते ब्याह और मर्ज संचालन। यदि आपके पास अक्सर सूचियों का एक समूह होता है, जिन्हें एक साथ जोड़ना या विलय करना होता है, तो एक सूची शायद एक अच्छा विकल्प है।

लेकिन अगर आपको ये ऑपरेशन करने की जरूरत नहीं है, तो शायद नहीं।

Answer 5

लिंक किए गए सूचियों की अंतर्निहित कैश / पेज-मित्रता की कमी उन्हें लगभग पूरी तरह से सी ++ डेवलपर्स द्वारा पूरी तरह से खारिज कर देती है, और उस डिफ़ॉल्ट रूप में अच्छे औचित्य के साथ।

लिंक्ड लिस्ट अब भी कमाल की हो सकती है

फिर भी जुड़ी हुई सूचियां अद्भुत हो सकती हैं जब एक निश्चित आवंटनकर्ता द्वारा समर्थित किया जाता है जो उन्हें उस स्थानिक इलाके को वापस देता है जिसमें उनके पास स्वाभाविक रूप से कमी है।

जहां वे यह कहते हैं कि हम एक सूची को दो सूचियों में विभाजित कर सकते हैं, उदाहरण के लिए, केवल एक नए सूचक को संचय करके और एक या दो सूचक को जोड़कर। हम केवल सूचक सूचक हेरफेर द्वारा निरंतर समय में एक सूची से दूसरी सूची में नोड्स स्थानांतरित कर सकते हैं, और एक खाली सूची में केवल एकल headसूचक की मेमोरी लागत हो सकती है ।

सरल ग्रिड त्वरक

एक व्यावहारिक उदाहरण के रूप में, एक 2 डी दृश्य सिमुलेशन पर विचार करें। इसमें एक मानचित्र के साथ एक स्क्रॉल स्क्रीन है जो 400x400 (160,000 ग्रिड सेल) तक फैलती है जिसका उपयोग प्रत्येक फ्रेम पर घूमते हुए लाखों कणों के बीच टकराव का पता लगाने जैसी चीजों के लिए उपयोग किया जाता है (हम यहां क्वाड-ट्री से बचते हैं क्योंकि वे वास्तव में इस स्तर के साथ बदतर प्रदर्शन करते हैं गतिशील डेटा)। कणों का एक पूरा गुच्छा लगातार हर फ्रेम पर घूम रहा है, जिसका अर्थ है कि वे एक ग्रिड सेल में निवास करने से लगातार दूसरे तक जाते हैं।

इस स्थिति में, यदि प्रत्येक कण एक एकल-लिंक्ड सूची नोड है, तो प्रत्येक ग्रिड सेल केवल एक headसंकेतक के रूप में शुरू कर सकता है जो इंगित करता है nullptr। जब एक नया कण पैदा होता है, तो हम इसे ग्रिड सेल में डालते हैं, यह headइस कण नोड को इंगित करने के लिए उस सेल के पॉइंटर को सेट करके रहता है । जब एक कण एक ग्रिड सेल से अगले तक जाता है, तो हम केवल संकेत जोड़ते हैं।

यह vectorsप्रत्येक ग्रिड सेल के लिए 160,000 स्टोर करने और फ्रेम-बाय-फ्रेम आधार पर हर समय बीच से पीछे धकेलने और हटाने से बहुत अधिक कुशल हो सकता है ।

std :: सूची

यह एक निश्चित आबंटक द्वारा समर्थित हाथ से लुढ़का हुआ, दखल देने वाली, अकेले जुड़ी हुई सूचियों के लिए है। std::listएक डबल-लिंक्ड सूची का प्रतिनिधित्व करता है और यह एकल सूचक (विक्रेता कार्यान्वयन द्वारा भिन्न) के रूप में खाली होने पर लगभग कॉम्पैक्ट नहीं हो सकता है, साथ ही यह कस्टम आवंटनकर्ताओं को std::allocatorफॉर्म में लागू करने के लिए दर्द की तरह है ।

मुझे मानना ​​होगा कि मैं कभी listभी उपयोग नहीं करता। लेकिन लिंक की गई सूची अभी भी अद्भुत हो सकती है! फिर भी वे उन कारणों के लिए अद्भुत नहीं हैं जिन्हें लोग अक्सर उनका उपयोग करने के लिए लुभाते हैं, और इतना अद्भुत नहीं है जब तक कि वे एक बहुत ही कुशल फिक्स्ड आवंटनकर्ता द्वारा समर्थित नहीं होते हैं जो कम से कम अनिवार्य पेज दोष और कैश से जुड़ी बहुत सी चीज़ों को कम कर देता है।

Comments

C ++ 11 के बाद से एक मानक एकल-लिंक्ड सूची है std::forward_list।

— शायरेक्स

Answer 6

आपको कंटेनर में तत्वों के आकार पर विचार करना चाहिए।

int तत्वों का वेक्टर बहुत तेज़ होता है क्योंकि अधिकांश डेटा सीपीयू कैश के अंदर फिट होते हैं (और SIMD निर्देशों का उपयोग संभवतः डेटा कॉपी के लिए किया जा सकता है)।

यदि तत्व का आकार अधिक है तो परीक्षण 1 और 3 का परिणाम महत्वपूर्ण रूप से बदल सकता है।

एक से बहुत व्यापक प्रदर्शन की तुलना :

यह प्रत्येक डेटा संरचना के उपयोग पर सरल निष्कर्ष निकालता है:

• नंबर क्रंच करना: उपयोग std::vectorयाstd::deque
• रैखिक खोज: उपयोग std::vectorयाstd::deque
• रैंडम डालें / निकालें:
  • छोटे डेटा का आकार: उपयोग std::vector
  • बड़े तत्व का आकार: उपयोग करें std::list(जब तक कि मुख्य रूप से खोज के लिए इरादा न हो)
• गैर-तुच्छ डेटा प्रकार: std::listजब तक आपको विशेष रूप से खोज के लिए कंटेनर की आवश्यकता न हो, तब तक उपयोग करें । लेकिन कंटेनर के कई संशोधनों के लिए, यह बहुत धीमा होगा।
• आगे की ओर धक्का: का उपयोग करें std::dequeयाstd::list

(एक साइड नोट के रूप std::dequeमें एक बहुत ही कम आंकडा संरचना है)।

सुविधा के दृष्टिकोण से std::listयह गारंटी प्रदान करता है कि पुनरावृत्तियाँ आपके द्वारा सम्मिलित और अन्य तत्वों को हटाने के रूप में कभी अमान्य नहीं हो जातीं। यह अक्सर एक महत्वपूर्ण पहलू है।

Answer 7

मेरी राय में सूचियों का उपयोग करने का सबसे प्रमुख कारण इटरेटर अमान्य है : यदि आप वेक्टर के तत्वों को जोड़ते / हटाते हैं, तो सभी संकेत, संदर्भ, पुनरावृत्तियाँ जिन्हें आपने इस वेक्टर के विशेष तत्वों के लिए रखा है, अमान्य हो सकते हैं और सूक्ष्म कीड़े हो सकते हैं। या विभाजन दोष।

सूचियों में ऐसा नहीं है।

सभी मानक कंटेनरों के लिए सटीक नियम इस StackOverflow पोस्ट में दिए गए हैं ।

Answer 8

संक्षेप में, उपयोग करने का कोई अच्छा कारण नहीं है std::list<>:

• यदि आपको एक अनियोजित कंटेनर की आवश्यकता है, तो std::vector<>नियम।
  (वेक्टर के अंतिम तत्व के साथ उन्हें हटाकर तत्वों को हटाएं।)

• यदि आपको एक सॉर्ट किए गए कंटेनर, std::vector<shared_ptr<>>नियमों की आवश्यकता है।

• यदि आपको विरल सूचकांक की आवश्यकता है, तो std::unordered_map<>नियम।

बस।

मुझे लगता है कि केवल एक ही स्थिति है जहां मैं एक लिंक की गई सूची का उपयोग करता हूं: जब मेरे पास ऐसी आकर्षक वस्तुएं हैं जिन्हें कुछ अतिरिक्त एप्लिकेशन लॉजिक को लागू करने के लिए किसी तरह से कनेक्ट करने की आवश्यकता होती है। हालाँकि, उस स्थिति में मैं कभी भी उपयोग नहीं करता std::list<>, बल्कि मैं ऑब्जेक्ट के अंदर एक (स्मार्ट) अगले पॉइंटर का सहारा लेता हूं, खासकर जब से ज्यादातर मामलों का उपयोग एक रैखिक सूची के बजाय एक पेड़ में होता है। कुछ मामलों में, परिणामी संरचना एक लिंक की गई सूची है, दूसरों में, यह एक पेड़ है, या एक निर्देशित चक्रीय ग्राफ है। इन बिंदुओं का प्राथमिक उद्देश्य हमेशा तार्किक संरचना का निर्माण करना है, वस्तुओं का प्रबंधन कभी नहीं करना। उसके std::vector<>लिए हमारे पास है।

Answer 9

आपको यह दिखाने की आवश्यकता है कि आप अपने पहले परीक्षण में आवेषण कैसे कर रहे थे। आपका दूसरा और तीसरा परीक्षण, वेक्टर आसानी से जीत जाएगा।

सूचियों का एक महत्वपूर्ण उपयोग तब होता है जब आपको पुनरावृत्ति करते समय वस्तुओं को हटाने का समर्थन करना होता है। जब वेक्टर संशोधित होता है, तो सभी पुनरावृत्तियाँ (संभावित) अमान्य होती हैं। सूची के साथ, हटाए गए तत्व के लिए केवल एक पुनरावृत्ति अमान्य है। अन्य सभी पुनरावृत्तियाँ मान्य रहेंगी।

कंटेनरों के लिए उपयोग का विशिष्ट क्रम वेक्टर, डीके, फिर सूची है। कंटेनर की पसंद आमतौर पर push_back choose वेक्टर, pop_front choose deque, Insert select लिस्ट पर आधारित होती है।

Comments

पुनरावृत्ति करते समय आइटम निकालते समय, आमतौर पर वेक्टर का उपयोग करना बेहतर होता है और परिणामों के लिए एक नया वेक्टर बनाते हैं

— अमारा

Answer 10

एक कारक जिसके बारे में मैं सोच सकता हूँ कि जैसे-जैसे एक वेक्टर बढ़ता है, वैसे-वैसे फ्री मेमोरी ख़राब होती जाएगी क्योंकि वेक्टर अपनी मेमोरी को हटाता है और बार-बार बड़ा ब्लॉक आवंटित करता है। यह सूचियों के साथ कोई समस्या नहीं होगी।

यह इस तथ्य के अतिरिक्त है कि push_backरिजर्व के बिना बड़ी संख्या में एस भी प्रत्येक आकार के दौरान एक प्रति का कारण होगा जो इसे अक्षम बनाता है। इसी तरह से बीच में डालने से सभी तत्वों की चाल सही हो जाती है, और इससे भी बदतर हो जाती है।

मैं नहीं जानता कि क्या यह एक प्रमुख चिंता है, लेकिन मुझे मेरे काम (मोबाइल गेम डेवलपमेंट) में वैक्टर से बचने का कारण बताया गया था।

Comments

नहीं, वेक्टर की नकल होगी और यह महंगा है। लेकिन लिंक की गई सूची का पता लगाना (यह पता लगाना है कि कहां डालें) भी महंगा है। कुंजी वास्तव में मापने के लिए है

— केट ग्रेगोरी

@ केटग्रेरी का मतलब मैं इसके अलावा था, मुझे तदनुसार संपादित करें

— कार्तिक टी

सही है, लेकिन विश्वास करें या नहीं (और अधिकांश लोग इसे नहीं मानते हैं) जिस लागत का आपने उल्लेख नहीं किया है, उससे जुड़ी सूची को ट्रेस करते हुए यह पता लगाने के लिए कि उन प्रतियों को कहां डाला जाए (खासकर यदि तत्व छोटे हैं (या जंगम, क्योंकि तब) वे चाल हैं)) और वेक्टर अक्सर (या आमतौर पर भी) तेज होता है। इस पर विश्वास करें या नहीं।

— केट ग्रेगोरी