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

एक सी ++ नोब आउट में मदद करें?

#include <iostream>
#include <cassert>
#include <stdexcept>
using namespace std;

template<class T> class mylist;

template<class T>
ostream& operator<<(ostream& out, const mylist<T>&l);

template <typename T>
class mylist {
public:
    struct node {
        T data;
        node* next_ptr;
        node(const T&d, node* n):data(d),next_ptr(n){}
    };
    node* head_ptr;
    friend ostream& operator<<  <>(ostream& out, const mylist<T>&l);

    class iterator {
        node* ptr;
    public:
        iterator(node*p):ptr(p){}
        iterator next(){return ptr->next_ptr;}
        T& operator*(){return ptr->data;}
        bool operator!=(const iterator& other){return ptr!=other.ptr;}
        iterator operator++(){ptr=ptr->next_ptr; return *this;}
    };
public:

    mylist():head_ptr(0) {}

    iterator begin(){return iterator(head_ptr);}
    iterator end(){return iterator(0);} 

    // returns a reference to the data in the ith node in the list
    // raise an out_of_bounds exception if not enough elements
    //****can't get error check to work here****/
    T& at(unsigned i)
    {   
        try{
        cout << endl;       
        unsigned j = 0;
        //node* node_pointer;
        iterator iter = begin();        
        while(j < i && iter.next() != NULL) 
        {

            ++iter;         
            j++;
            /*if(!(iter.next() != NULL))
            {   throw out_of_range("out of bounds");
                }*/         
        }                       
        cout << "leaving now" << endl;      
        return *iter;}
        catch(out_of_range& oor){cerr << "out of range" << oor.what() << endl;}

    }

    // same as at
    //****can't get error check to work here****/
    T& operator[](unsigned i)
    {
        try{
        cout << endl;       
        unsigned j = 0;
        //node* node_pointer;
        iterator iter = begin();        
        while(j < i && iter.next() != NULL) 
        {       
            ++iter;         
            j++;
            /*if(!(iter.next() != NULL))
            {   throw out_of_range("out of bounds");
                }*/             
        }                       
        cout << "leaving now" << endl;      
        return *iter;}
            catch(out_of_range& oor){cerr << "out of range" << oor.what() << endl;}
    }   

    // insert after the node 'pointed' by place
    void insert_after(const T&data, const iterator &place) 
    {       
        if(empty())
            push_front(data);




    }

    // removes the first node, returns its data
    T pop_front(){
        return 0;
    }

    // removes the node after the node 'pointed' by place
    void remove_after(const iterator &place) {

    }

    // destructor, needs to delete all nodes in the list
    ~mylist() {

    }

    // you're done here

    // insert at beginning of list
    void push_front(const T& data) {
        head_ptr=new node(data,head_ptr);
    }

    bool empty() { return head_ptr==0;}

    void push_back(const T&data) {
        if(empty())
            push_front(data);

        node* last_ptr=head_ptr;
        while(last_ptr->next_ptr != 0)
            last_ptr=last_ptr->next_ptr;
        // pointing to last node on the list
        last_ptr->next_ptr=new node(data,0);
    }

    unsigned length() {
        unsigned l=0;
        node*current_ptr=head_ptr;
        while(current_ptr!=0) {
            l++;
            current_ptr=current_ptr->next_ptr;
        }
        return l;
    }

    void print_all(void) {
        cout << "mylist{";
        for(node*current_ptr=head_ptr;  
                current_ptr!=0; 
                current_ptr=current_ptr->next_ptr){
            cout << current_ptr->data << " ";
        }
        cout <<"}";
    }
};


template<typename T>
ostream& operator<<(ostream& out, const mylist<T>&l) {
    out << "mylist{";

    typename mylist<T>::node* current_ptr;

    for(current_ptr=l.head_ptr; current_ptr!=0;     
                    current_ptr=current_ptr->next_ptr) {
        out << current_ptr -> data << " ";
    } 
    out <<"}";
    return out;
}


int main(void)
{
    mylist<int>::node h(4,0);
    mylist<int> l;
    mylist<int> z;
    cout << l.length() << endl; 
    l.push_front(6);
    l.push_front(7);
    cout << l.length() << endl;
    l.push_back(10);        
    l.print_all();
    unsigned int i = 5;     

    cout << "data at i = "<< i <<" is: " << l.at(i) << endl;
    cout << "data at l[" << i <<"] is " << l[i] << endl;
    z.insert_after(23,iter);    
    z.push_front(18);
    z.push_front(x.data);
    z.print_all();
    cout << endl << "goodbye" << endl;

    /*for(mylist<int>::iterator curr=l.begin(); curr!=l.end(); ++curr) {
        cout << *curr << endl;
    }*/ 

}
1
infinite_loop 10 जून 2011, 07:45

1 उत्तर

सबसे बढ़िया उत्तर

चूंकि यह गृहकार्य है, मैं उदाहरण कोड नहीं दूंगा, लेकिन: आपके पास mylist के लिए अपनी iterator कक्षा में node* तक पहुंचने का एक तरीका होना चाहिए। insert_after विधि तब उस नोड के next_ptr को एक नया नोड सम्मिलित करने के लिए संशोधित कर सकती है।

1
Sven 10 जून 2011, 07:50
1
+1। एक छोटी सी और युक्ति - यथासंभव चुनिंदा रूप से ptr तक पहुंच की अनुमति देने का प्रयास करें, ताकि iterator का उपयोग करने वाला बाहरी क्लाइंट कोड इनकैप्सुलेशन को तोड़ न सके।
 – 
Tony Delroy
10 जून 2011, 07:59
क्षमा करें दोस्तों, मुझे लगता है कि मुझे इसका कुछ और अध्ययन करना होगा ताकि मैं आपके सुझावों को समझना भी शुरू कर सकूं। धन्यवाद
 – 
infinite_loop
10 जून 2011, 08:19
@infinite_loop: ठीक है, इटरेटर के node* ptr public (बस जब तक आप इसे काम नहीं कर लेते) बनाकर शुरू करें, फिर insert_after में, *place.ptr डालने के लिए नोड होगा इसके बाद: आप इसके next_ptr में एक नया नोड असाइन करना चाहते हैं, जिसे data और मौजूदा place.ptr->next_ptr को बनाए रखने के लिए बनाया जाना चाहिए।
 – 
Tony Delroy
10 जून 2011, 10:34