Does my class satisfy the requirements of an iterator?

Question

Consider the following class:

template <class T>
struct X {
    T& operator*() & { return t; }
    T& operator*() && = delete; 
    X& operator++() { return *this; }
    T t;
};

Does this class satisfy requirements of Iterator concept by the C++ Standard? Object of this class is incrementable and dereferenceable. But dereference of rvalue object is forbidden.

int main() {
    X<int> x;
    *x; // ok
    *X<int>(); // fail. But is it really necessary for Iterator by Standard?
}

Answer 1

With a strict reading of the standard; [iterator.iterators]/2 (§24.2.2/2) does hint at the type X qualifying as an iterator;

...a and b denote values of type X or const X

...r denotes a value of X&...

A type X satisfies the Iterator requirements if:

• X satisfies the CopyConstructible, CopyAssignable, and Destructible requirements ([utility.arg.requirements]) and lvalues of type X are swappable ([swappable.requirements]), and

• the expressions in Table (below) are valid and have the indicated semantics.

  • *r (r is dereferenceable)
  • ++r (returns X&)

Given the code;

template <class T>
struct X {
    T& operator*() & { return t; }
    T& operator*() && = delete; 
    X& operator++() { return *this; }
    T t;
};
int main()
{
    X<int> x;
    ++x;
    int i = *x;
    X<int> y(x);
    using std::swap;
    std::swap(x, y);
}

Certainly does seem to satisfy those requirements.

However, the story continues, the Iterator concept, as defined above, is not listed as one of the Iterator Categories in the standard §24.2.1/2;

This International Standard defines five categories of iterators, according to the operations defined on them: input iterators, output iterators, forward iterators, bidirectional iterators and random access iterators...

They all define an operation *a and *r++ for which the type X fails to compile;

int j = *x++; // fails to compile even with the inclusion of the post increment operator
const X<int> xc {};
int ic = *x1; // no const overloads

For an iterator to be usable within one of the defined categories, it needs to include further members for de-referencing const values, lvalues and rvalues, post increment etc. In the spirit of the standard;

Iterators are a generalization of pointers that allow a C++ program to work with different data structures (containers) in a uniform manner.

The guidance here for the overloaded members and operators is that they can/should be added to enforce compliance and optimise (if possible) the implementation of the semantics of the generalised pointer - not to disallow the semantics; limiting the semantics could have unintended consequences.

Answer 2

Well, the standard doesn't say anything about rvalue referenced iterators. And did not even recognize iterators whose members are overloaded by their reference types. But your code seems acceptable to be an iterator*, because in defining the requirements for an iterator...

Quoting section 24.2.2 of the latest C++14 standard draft, (emphasis are mine)

24.2.2.2: A type X satisfies the Iterator requirements if:

— X satisfies the CopyConstructible, CopyAssignable, and Destructible requirements (17.6.3.1) and lvalues of type X are swappable (17.6.3.2), and

— the expressions in Table 106 are valid and have the indicated semantics.

• *r : r is dereferenceable

• ++r : r is incrementable

Other than this, there is no extra constraint on iterator.

---

* Of cause, assuming the resulting X<typename ...> satisfies the first listed condition