Как правильно использовать вложенные классы в моем файле hpp и файле cpp? - PullRequest
Новая
       28

Как правильно использовать вложенные классы в моем файле hpp и файле cpp?

0 голосов
/ 04 ноября 2019

Я пытаюсь реализовать односвязный список с итератором в качестве вложенного класса класса связанного списка. Я получаю много ошибок, связанных с работой с итераторами. Я потратил несколько часов на изучение этого, но, к сожалению, многие решения включают шаблоны, и я не могу их использовать. Каждый раз, когда я исправляю одну проблему, появляется новая.

В моем файле cpp появляются следующие ошибки:

  • Использование необъявленного идентификатора 'current'
  • Ожидается ';'после объявления верхнего уровня (я очень озадачен, почему я получаю это, потому что я думал, что задержал итератор в своем hpp-файле
  • Перегруженный «оператор ++» должен иметь хотя бы один параметр класса или типа перечисления (мыв этом случае не должно быть параметров для наших перегруженных операторов, верно? Я просто хочу повторить, чтобы я теперь указывал на следующий элемент в связанном списке
  • Недопустимое использование «this» вненестатическая функция-член
  • 'Итератор' не является классом, пространством имен или перечислением

Я продолжу проводить дополнительные исследования и сообщу здесь, если выясню, чтонеправильно с моим кодом, надеюсь, помочь, если у других есть тот же вопрос.

Большое спасибо заранее!

Вот мой файл hpp: 

#ifndef linkedlist_h
#define linkedlist_h


  class LinkedList {
  public:


    struct Node {
      //Node(Node *aNext=nullptr) : next(aNext) {}
        int  value;   //this is the value you want to save
        Node *next;  //this points to the next node in the list (or nullptr)
    };
    //friend class Iterator; //do Ineed this even though it's a nested class

    Node *root;

    //---------------------------------------------------------------

    //add a NESTED Interator class...
    class Iterator {
    public:
        Iterator(); //default constructor
        Iterator(Node* aNode);//constructor
        ~Iterator(); //dtor
        Iterator operator++();
        Iterator operator++(int);
        bool operator==(const Iterator &anIterator);
        bool operator!=(const Iterator &anIterator);
        int operator*();
        operator Node*();
        Node *current; //do I need to put LinkedList since it's a nested class?

      //add all the necessary operators

    protected:
    };

    //--------------------------------------------------------------

    LinkedList(); //default constructor...
    LinkedList(const LinkedList& aCopy); //copy ctor
    ~LinkedList(); //dtor
    LinkedList& operator=(const LinkedList& aCopy); //assignment operator

    void append(int value);
    void prepend(int value);
    void remove(int value);
    int size(); //needs to return unsigned int????
    Iterator begin();
    Iterator end();
    Iterator find(int value);


  protected:
  };




#endif /* linkedlist_h */

Вот мойфайл cpp: 

#include <stdio.h>
#include "LinkedList.hpp"


//class Iterator;
  LinkedList::LinkedList() {
      root=nullptr;
  }

LinkedList::LinkedList(const LinkedList& aCopy){ //copy ctor
    Node *temp=aCopy.root;
    Node *newNode = new Node;
    root=newNode;

    while (temp != nullptr){
        newNode-> value=temp->value;
        temp=temp->next;
        if (temp !=nullptr){
            newNode->next=new Node;
            newNode=newNode->next;
        }
        else{ newNode->next=nullptr;}
    }
}

LinkedList& LinkedList::operator=(const LinkedList &aCopy){ //assignment operator
    while(root!=nullptr){
        Node* oneBefore= root;
        root =root->next;
        delete oneBefore;
    }
    Node *newNode= new Node;
    Node *temp=aCopy.root;
    root=newNode;

    while(temp!=nullptr){
        newNode->value=temp->value;
        temp=temp->next;
        if(temp!=nullptr){
            newNode->next=new Node;
            newNode=newNode->next;
        }
        else{newNode->next=nullptr;}
    }
    return *this;
}

LinkedList::~LinkedList(){ //dtor
    Node* oneBefore = nullptr;
    while(root!=nullptr){
        oneBefore=root;
        root=root->next;
        delete oneBefore;
    }
}

void LinkedList::append(int value){
    Node* newNode=new Node;
    newNode->value=value;
    if(root!=nullptr){
        Node* temp = root;
        while (temp->next !=nullptr){
            temp=temp->next;
        }
        newNode->next=nullptr;
        temp->next=newNode;
    }
    if(root==nullptr){
        newNode->next=nullptr;
        root=newNode;
    }

}

void LinkedList::prepend(int value){
    Node* newNode=new Node;
    newNode->value=value;
    if (root!=nullptr){
        newNode->next=root;
        root=newNode;
    }
    if(root==nullptr){
        root=newNode;
        newNode->next=nullptr;
    }
}

void LinkedList::remove(int value){
    if(root==nullptr){
        Node *before=nullptr;
        Node *temp=root;
        if(temp->value==value){
            root=temp->next;
        }
        else{
            while(temp->value!=value &&temp->next != nullptr){
                before=temp;
                temp=temp->next;
            }
            if(temp->value==value){
                before->next=temp->next;
            }
        }
        delete temp;
    }
}

int LinkedList::size(){
    Node* aNode = root;
    int numElements=0;
    while(aNode!=nullptr){
        aNode=aNode->next;
        numElements=numElements+1;
    }
    return numElements;
}

LinkedList::Iterator LinkedList::begin(){
    return LinkedList::Iterator(root);
}

LinkedList::Iterator LinkedList::end(){
    Node *aNode=root;
    while(aNode!=nullptr){
        aNode=aNode->next;
    }
    return LinkedList::Iterator(aNode);
}

LinkedList::Iterator Iterator(){
    current=nullptr;
}
LinkedList::Iterator(Node *aNode){
    current=aNode;
}

LinkedList::Iterator operator++(){//I have no idea what the difference is supposed to be between this one and the one below
    current=current->next;
    return *this;
}

LinkedList::Iterator& Iterator::operator=(const LinkedList::Iterator& aCopy){ //assignment operator
    current=aCopy.current;
    return *this;
}

bool Iterator::operator !=(const LinkedList::Iterator& aCopy){
    return current != aCopy.current;
}

bool Iterator::operator==(const LinkedList::Iterator& aCopy){
    return current==aCopy.current;
}

int Iterator::operator*(){
    return current->value;
}

ОБНОВЛЕНИЕ: приведенные ниже советы очень помогли! Спасибо вам большое! Последняя ошибка, которую я имею (я отмечу, где это показано на компиляторе ниже): - "ОпределениеимплицитноОбъявлен оператор копирования копии "

Обновлен файл hpp: 


#ifndef linkedlist_h
#define linkedlist_h


  class LinkedList {
  public:


    struct Node {
      //Node(Node *aNext=nullptr) : next(aNext) {}
        int  value;   //this is the value you want to save
        Node *next;  //this points to the next node in the list (or nullptr)
    };
    //friend class Iterator; //do Ineed this even though it's a nested class

    Node *root;

    //---------------------------------------------------------------

    //add a NESTED Interator class...
    class Iterator {
    public:
        Iterator();//default constructor
        //Iterator() : current(nullptr) {}
        Iterator(Node* aNode);
        //Iterator(Node* aNode): current(aNode){};//constructor
        ~Iterator(); //dtor
        Iterator operator++();
        Iterator operator++(int);
        bool operator==(const Iterator &anIterator);
        bool operator!=(const Iterator &anIterator);
        int operator*();
        operator Node*();
        Node *current; //do I need to put LinkedList since it's a nested class?

      //add all the necessary operators

    protected:
    };

    //--------------------------------------------------------------

    LinkedList(); //default constructor...
    LinkedList(const LinkedList& aCopy); //copy ctor
    ~LinkedList(); //dtor
    LinkedList& operator=(const LinkedList& aCopy); //assignment operator

    void append(int value);
    void prepend(int value);
    void remove(int value);
    int size(); //needs to return unsigned int????
    Iterator begin();
    Iterator end();
    Iterator find(int value);


  protected:
  };




#endif /* linkedlist_h */

Обновлен файл cpp: 

#include <stdio.h>
#include "LinkedList.hpp"


//class Iterator;
  LinkedList::LinkedList() {
      root=nullptr;
  }

LinkedList::LinkedList(const LinkedList& aCopy){ //copy ctor
    Node *temp=aCopy.root;
    Node *newNode = new Node;
    root=newNode;

    while (temp != nullptr){
        newNode-> value=temp->value;
        temp=temp->next;
        if (temp !=nullptr){
            newNode->next=new Node;
            newNode=newNode->next;
        }
        else{ newNode->next=nullptr;}
    }
}

LinkedList& LinkedList::operator=(const LinkedList &aCopy){ //assignment operator
    while(root!=nullptr){
        Node* oneBefore= root;
        root =root->next;
        delete oneBefore;
    }
    Node *newNode= new Node;
    Node *temp=aCopy.root;
    root=newNode;

    while(temp!=nullptr){
        newNode->value=temp->value;
        temp=temp->next;
        if(temp!=nullptr){
            newNode->next=new Node;
            newNode=newNode->next;
        }
        else{newNode->next=nullptr;}
    }
    return *this;
}

LinkedList::~LinkedList(){ //dtor
    Node* oneBefore = nullptr;
    while(root!=nullptr){
        oneBefore=root;
        root=root->next;
        delete oneBefore;
    }
}

void LinkedList::append(int value){
    Node* newNode=new Node;
    newNode->value=value;
    if(root!=nullptr){
        Node* temp = root;
        while (temp->next !=nullptr){
            temp=temp->next;
        }
        newNode->next=nullptr;
        temp->next=newNode;
    }
    if(root==nullptr){
        newNode->next=nullptr;
        root=newNode;
    }

}

void LinkedList::prepend(int value){
    Node* newNode=new Node;
    newNode->value=value;
    if (root!=nullptr){
        newNode->next=root;
        root=newNode;
    }
    if(root==nullptr){
        root=newNode;
        newNode->next=nullptr;
    }
}

void LinkedList::remove(int value){
    if(root==nullptr){
        Node *before=nullptr;
        Node *temp=root;
        if(temp->value==value){
            root=temp->next;
        }
        else{
            while(temp->value!=value &&temp->next != nullptr){
                before=temp;
                temp=temp->next;
            }
            if(temp->value==value){
                before->next=temp->next;
            }
        }
        delete temp;
    }
}

int LinkedList::size(){
    Node* aNode = root;
    int numElements=0;
    while(aNode!=nullptr){
        aNode=aNode->next;
        numElements=numElements+1;
    }
    return numElements;
}

LinkedList::Iterator LinkedList::begin(){
    return LinkedList::Iterator(root);
}

LinkedList::Iterator LinkedList::end(){
    Node *aNode=root;
    while(aNode!=nullptr){
        aNode=aNode->next;
    }
    return LinkedList::Iterator(aNode);
}

LinkedList::Iterator::Iterator() : current(nullptr) {}

LinkedList::Iterator::Iterator(Node* aNode): current(aNode){};

LinkedList::Iterator LinkedList::Iterator::operator++(){//I have no idea what the difference is supposed to be between this one and the one below
    current=current->next;
    return *this;
}

LinkedList::Iterator& LinkedList::Iterator::operator=(const LinkedList::Iterator& aCopy) noexcept{ //assignment operator; THIS IS WHERE I SEE AN ERROR
    current=aCopy.current;
    return *this;
}

bool LinkedList::Iterator::operator !=(const LinkedList::Iterator& aCopy){
    return current != aCopy.current;
}

bool LinkedList::Iterator::operator==(const LinkedList::Iterator& aCopy){
    return current==aCopy.current;
}

int LinkedList::Iterator::operator*(){
    return current->value;
}

1 Ответ

0 голосов
/ 04 ноября 2019

Первая проблема (как я уже сказал в качестве комментария) заключалась в том, что определения методов вложенного класса должны выглядеть как LinkedList::Iterator::Iterator() { ... } или bool LinkedList::Iterator::operator!=(...) { ... }. (Я просто пишу это здесь снова, чтобы было легче найти, если у кого-то есть такая же проблема)

Причина, по которой вы получаете ошибку в определении оператора присваивания, заключается просто в том, что вы не объявилиоператор присваивания для этого класса в вашем заголовке.

В качестве бонусного раунда: разница между operator++() и operator++(int) заключается в том, что первый вызывается с ++a (предварительное увеличение), тогда какдругой вызывается с a++ (постинкремент). Перед инкрементом следует также возвращать ссылку на тот же объект (аналогично оператору выделения), в то время как постинкремент возвращает копию объекта, как это было до приращения.

...