На основе диапазона l oop для связанного списка - PullRequest
Новая
       4

На основе диапазона l oop для связанного списка

0 голосов
/ 17 февраля 2020

Полагаю, что-то не хватает в операторе ++ (). Я хочу реализовать Range на основе l oop в следующем коде связанного списка. Я не уверен, что мне в нем не хватает. 

struct Node {
    Node() {}
    Node(int e, Node* n) : elem(e), next(n) {  }
    int elem = 0;
    Node* next = nullptr;

    Node& operator ++() {
        Node* current = this;
        if( current != nullptr ) {
            current = current->next;
            return *current;
        }
    }

    int& operator *() {
        return this->elem;
    }

    bool operator !=(Node const& rhs) const {
        return this->elem != rhs.elem;
    }

    int* begin() {
        return &this->elem;
    }

    int* end() {
        return nullptr;
    }

};

void add(Node& n, int x) {
    n.next = new Node(x, n.next);
}


int main() {

    Node head;
    add(head, 1);
    add(head, 2);
    add(head, 3);
    add(head, 4);
    add(head, 5);

    for (int x : head) {
        std::cout << x << " ";
    }
    std::cout << "2nd " << std::endl;
    std::cout << std::endl;
    for (int& x : head) {
        x = 7;
    }

    std::cout << "3rd " << std::endl;
    for (const int& x : head) {
        std::cout << x << " ";
    }
    std::cout << std::endl;

    return 0;
}

Я не уверен, что добавить в ++ оператор. Я хочу, чтобы это было в той же структуре, вместо того, чтобы иметь отдельный класс Iterator.

1 Ответ

0 голосов
/ 17 февраля 2020

Структура Node содержит один элемент int. Этот элемент int абсолютно не связан с другими элементами int.

То, что вы делаете с begin и оператором приращения ++ - это обработка один узлов int элемент в качестве первого элемента массива. Это означает, что ваш код немедленно выйдет за пределы go.

Чтобы решить вашу итерационную проблему, я сначала предлагаю вам абстрагировать список и узлы в различные структуры. Затем вы можете легко создать структуру-оболочку, которая содержит указатель на текущий узел в итерации списка. Эта структура-обертка должна затем перегрузить оператор ++, который переведет go к следующему узлу в списке.

Несколько графически это может быть что-то вроде 

+------+     +--------+     +--------+     +--------+
| list | --> | node 1 | --> | node 2 | --> | node 3 | --> ...
+------+     +--------+     +--------+     +--------+
             ^
             |
             +----------+
             | iterator |
             +----------+

Затем вы увеличиваете итератор и получаете следующее: 

+------+     +--------+     +--------+     +--------+
| list | --> | node 1 | --> | node 2 | --> | node 3 | --> ...
+------+     +--------+     +--------+     +--------+
                            ^
                            |
                            +----------+
                            | iterator |
                            +----------+

И так далее ...

...