How to overload an iterator so it can be incremented in a dereferenceable state?

Question

to give context i'm trying to re-implement vector container, and while reading about it's iterator system requirements, i've stumbled upon this requirement from cplusplus reference:

can be incremented (if in a dereferenceable state ). the result is either dereferenceable or past-the-end iterator.
EX: ++a , a++, *a++

i've already overloaded the increment and dereference operators as so:

class iterator {
    ...
    inline iterator& operator++() {
        ++_ptr;
        return *this;
    };

    inline iterator operator++(int) {
        iterator tmp(*this);
        operator++();
        return (tmp);
    };
    
    inline reference operator*() const {
        return _ptr;
    };
    ...
}

i've researched a bit about this requirement and didn't found any informations mentioning this property, so i assumed it's irrelevant and handled by default by the compiler as long as i overload the operators separately, is that the case or should i implement my iterator in a way so that it can be incremented in a dereferenceable state.

But your iterator *can* be incremented in a dereferenceable state. — molbdnilo, Sep 27 '22 at 09:34
@Jarod42 can you please elaborate in that more , what's the consequence of that ? — interesting, Sep 27 '22 at 09:36
I meant you can get rid of writing your own iterator class, something like [that](https://godbolt.org/z/Evq43eceh) is *"valid"*. I quote "valid", as pointer arithmetic has some restrictions which make some used code pedantically invalid. see [implementing-a-stdvector-like-container-without-undefined-behavior](https://stackoverflow.com/questions/52996590/implementing-a-stdvector-like-container-without-undefined-behavior). — Jarod42, Sep 27 '22 at 10:05

463035818_is_not_an_ai · Accepted Answer · 2022-09-27T09:26:47.490

You cannot increment an end iterator, it is not dereferenceable. You cannot increment an invalid iterator, it is not dereferenceable.

Preconditions do not necessarily mean that you have to do something extra. They only give information when some operation, here increment, is defined.

For example

 std::vector<int> foo;
 auto it = foo.end();
 ++it;    // undefined

Incrementing the end iterator is undefined.

When a user calls your operator++ on an invalid iterator (and then try to dereference it) it is their fault. They broke the contract.

For analogy consider a function:

int div(int a,int b) { return a/b; }

And specification states: "You can only call the function with b!=0". The function does not need to check b!=0, because if a user calls it with b==0 they broke the contract.

In a debug build you might want to add some convenience and check if preconditions hold before actually incrementing the iterator. Though in a release build this would incur unnecessary cost and be a nuisance for anybody who only increments dereferencable iterators (as they should).

How to overload an iterator so it can be incremented in a dereferenceable state?

1 Answers1