एक लिंक्ड सूची

Question

के लिए एक प्रतिलिपि निर्माता बनाना यह होमवर्क

मैं अपने सी ++ वर्ग के लिए एक लिंक की गई सूची वर्ग को लागू करने पर काम कर रहा हूँ है, और प्रतिलिपि निर्माता मेरे लिए बहुत भ्रामक हो गया है।

लिंक्ड सूची structs elems कहा जाता है के शामिल है:

struct Elem 
    { 
     int pri; 
     data info; 
     Elem * next; 
    }; 
    Elem * head; 

की जानकारी है कि Elem में संग्रहित है एक अलग, कस्टम वर्ग है।

प्रतिलिपि निर्माता के लिए हस्ताक्षर है:

linkedList::linkedList(const linkedList &v) 

मुद्दा मैं कर रहा हूँ ज्यादातर मेरे तर्क ले रहे हैं और वास्तव में कोड के रूप में यह लिख रहा है। करने के लिए

मेरे सामान्य विचार है:

1. सेट सिर v.head को (सिर = v.head)
2. वी के (pri = v.pri को Elem के मूल्यों सेट, जानकारी = v.info अगले = v.next)
3. दोहराएं के माध्यम से, चरण दोहराते 2.

इस सामान्य विचार है?

कोई भी मदद महान होगी। याद रखें, यह होमवर्क है, इसलिए कोई सीधा जवाब नहीं है!

अपना समय

के लिए धन्यवाद =================================== ================================================== ================================================== =============================

आपके समय के लिए धन्यवाद!

मुझे लगता है मैं यह पता लगा है:

//Copy Constructor 
LinkedList::LinkedList(const LinkedList &v) 
{ 
Elem * p1 = 0;//current 
Elem * p2 = 0;//next 

if(v.head == 0) 
    head = 0; 

else 
{ 
    head = new Elem; 
    head -> pri = v.head -> pri; 
    head -> info = v.head -> info; 

    p1 = head; 
    p2 = v.head -> next; 
} 

while(p2) 
{ 
    p1 -> next = new Elem; 
    p1 = p1 -> next; 
    p1 -> pri = p2 -> pri; 
    p1 -> info = p2 -> info; 

    p2 = p2 -> next; 
} 
p1 -> next = 0; 
} 

मुझे लगता है कि काम करता है यकीन है कि हूँ। मैंने मदद करने के लिए कुछ तार्किक चित्र खींचे, और मैंने किसी भी मुद्दे में भाग नहीं लिया।

Answer 1

आपको चरण 1 और चरण 2 के भाग से सावधान रहना होगा। चरण 1 को एक नया नोड आवंटित करना चाहिए और head के रूप में उपयोग करना चाहिए। चरण 2 में, next = v.next का हिस्सा, जब तक कि आपका इरादा एक उथली प्रतिलिपि बनाना नहीं है, गलत है।

जब आप एक कंटेनर की तरह एक कंटेनर की प्रतिलिपि बनाते हैं, तो आप शायद एक गहरी प्रतिलिपि चाहते हैं, इसलिए नए नोड्स को बनाने की आवश्यकता है और केवल डेटा कॉपी किया गया है। नई सूची के नोड्स में next और prior पॉइंटर्स को उस सूची के लिए विशेष रूप से बनाने वाले मूल नोड्स के नोड्स को संदर्भित करना चाहिए, न कि मूल सूची से नोड्स। इन नए नोड्स में मूल सूची से संबंधित डेटा की प्रतियां होंगी, ताकि नई सूची को मूल्य, या गहरी प्रतिलिपि माना जा सके।

सूचना कैसे आरेख के दीप कॉपी भाग में, नोड्स में से कोई भी पुरानी सूची में नोड्स को इंगित:

यहाँ एक चित्र उथले और गहरी नकल के बीच मतभेद को दर्शाया गया है । उथले और गहरी प्रतियों के बीच के अंतर के बारे में अधिक जानकारी के लिए, object copying पर विकिपीडिया लेख देखें।

Answer 2

1. आपको this->head = v.head सेट नहीं करना चाहिए। क्योंकि सिर बस एक सूचक है। आपको एक नया सिर बनाने और v.head से अलग-अलग मानों को अपने नए सिर में कॉपी करने की आवश्यकता है। अन्यथा आपके पास एक ही चीज़ को इंगित करने वाले दो पॉइंटर्स होंगे।

2. फिर आप एक अस्थायी Elem सूचक है कि v.head साथ शुरू होता है बना सकते हैं और सूची के माध्यम से पुनरावृति, नई प्रतिलिपि में नए Elem संकेत करने के लिए अपने मूल्यों को कॉपी करना होगा।

3. ऊपर देखें।

Answer 3

आपकी कॉपी कन्स्ट्रक्टर प्रति को क्या चाहिए? इसे pri कॉपी करना चाहिए - आसान। इसे info कॉपी करना चाहिए - साथ ही साथ आसान भी। और यदि next शून्य नहीं है, तो इसे भी कॉपी करना चाहिए। आप next कैसे कॉपी कर सकते हैं? रिकर्सिव सोचें: ठीक है, next एक Elem * है, और Elem में एक कॉपी कन्स्ट्रक्टर है: संदर्भित Elem को कॉपी करने के लिए इसका उपयोग करें और इसका संदर्भ लें।

आप इसे भी हल कर सकते हैं, लेकिन पुनरावर्ती समाधान अधिक सहज ज्ञान युक्त है।

Answer 4

तो यहाँ मेरा उत्तर है (कि अगर अपना होमवर्क या नहीं करने के लिए फिट बैठता है पता नहीं - प्रशिक्षकों कभी कभी अपने स्वयं के विचारों हो जाते हैं;):

आम तौर पर एक प्रति निर्माता चाहिए "प्रतिलिपि" अपने वस्तु। अर्थात। मान लें कि आपने लिंक्ड लिस्ट एल 1 किया है, और एक लिंक्ड लिस्ट एल 2 = एल 1 (जो लिंक्ड लिस्ट :: लिंक्डलिस्ट (एल 1) कहता है), फिर एल 1 और एल 2 इस अर्थ में पूरी तरह अलग वस्तुएं हैं कि एल 1 में संशोधन एल 2 को प्रभावित नहीं करता है और इसके विपरीत।

जब आप केवल पॉइंटर्स असाइन करते हैं तो आपको वास्तविक प्रति प्राप्त नहीं होगी, क्योंकि उनमें से किसी एक को संदर्भित करने और संशोधित करने से दोनों ऑब्जेक्ट प्रभावित होंगे।

आप अपनी स्रोत सूची में प्रत्येक तत्व की वास्तविक गहरी प्रतिलिपि बनाना चाहते हैं (या केवल एक प्रति-मांग मांगें, यदि आप कल्पना करना चाहते हैं)।

Answer 5

आप लाइन return;

if(v.head == 0) 
    head = 0; 

आप बाहर निकलने के लिए की जरूरत है के बाद, सही भूल गए?