Using `Node *` as an Iterator for a List

Question

#include <iostream>
#include <algorithm>

struct Node
{
    int value_;
    Node* next_;

    Node(int value, Node* next = nullptr)
        : value_(value)
        , next_(next)
    {}
};

Node* operator++(Node* node)
{
    node = node->next_;
    return node;
}

int operator*(Node* node)
{
    return node->value_;
}

int main()
{
    Node* first = new Node(10);
    first->next_ = new Node(20);
    first->next_->next_ = new Node(17);

    Node* endIter = nullptr;

    std::cout << std::accumulate(first, endIter, 0) << std::endl;
}

In this example, I tried using Node*as an iterator for a list. I get compiler errors

  1 main.cpp:15:28: error: Node* operator++(Node*) must have an argument of class or enumerated type
  2  Node* operator++(Node* node)
  3                             ^
  4 main.cpp:21:25: error: int operator*(Node*) must have an argument of class or enumerated type
  5  int operator*(Node* node)

It seems that I can not reboot operator++and operator*for pointers.

I copied these overloads from a book Stroustrup: The C++ Programming Language (4th Edition) pg 703.

Can someone explain what I did wrong?

Answer 1

The input std::accumulatemust comply with the requirements of the InputIterator .

One of the requirements of InputIterator is support for the pre-increment operator.

pre-increment Node*, .

Node* operator++(Node* node) { ... }

, Node*. operator++ Node, Node*.

++ 11 ( ):

13.5

6 -, - , , , , .

Answer 2

. Node.

class iterator {
public:
  iterator(Node *node): _node(node) {}
  iterator operator++() {
    _node = _node->next;
    return *this;
  }
  iterator operator++(int) {
    iterator tmp = *this;
    ++(*this);
    return tmp;
  }
  bool operator == (const iterator &iter) const {
    return _node == iter._node;
  }
  int operator*() {
    return _node->value;
  }
private:
  Node *_node;
};