Question

Please tell me how the operator->() in being defined for the iterator of std::list in order to refer members of the element that is being pointed by an iterator.

EDIT:

The problem is that if you implement like this (Fred Nurk):

template<class T>
struct list {
private:
  struct Node {  // internal class that actually makes up the list structure
    Node *prev, *next;
    T data;
  };

public:
  struct iterator {  // iterator interface to the above internal node type
    T* operator->() const {
      return &_node->data;
    }
  private:
    Node *_node;
  }
};

Then when you write:

struct A {
  int n;
};
void f() {
  list<A> L;  // imagine this is filled with some data
  list<A>::iterator x = L.begin();

  x->n = 42;
}

Then

x->n I understand like x->operator->()n which is equivalent to (A ponter to a)n which is a nonsence. How to understand this part. Some answers tell that it is equivalent to x->operator->()->n; (instead of x->operator->()n) but I don’t understand why. Please explain me this.

Answer 1

With many details elided, here is the gist of how it works:

template<class T>
struct list {
private:
  struct Node {  // internal class that actually makes up the list structure
    Node *prev, *next;
    T data;
  };

public:
  struct iterator {  // iterator interface to the above internal node type
    T* operator->() const {
      return &_node->data;
    }
  private:
    Node *_node;
  }
};

Thus, given:

struct A {
  int n;
};
void f() {
  list<A> L;  // imagine this is filled with some data
  list<A>::iterator x = L.begin();

  x->n = 42;
  // x.operator->() returns an A*
  // which gets -> applied again with "n"
}