如何检查迭代器指定的范围是否有效？

Question

Many of the standard library containers have operations that accept a range specified by iterators. For example, std::list::assign(InputIterator first, InputIterator last) .

But because many of these operations do not throw exceptions, if the range specified by [first,last) is not valid, it will cause undefined behaviour.

So what is a valid range? I assume it means that first comes before or is equal to last in the container, because when I tried otherwise (ie first comes after last ), the program's execution would hang.

For example:

std::list.assign(container.begin(), container.end()); // valid range
std::list.assign(container.end(), container.begin()); // invalid range

Now with an assumption of what a valid range is, how can we check if a range is valid?

I came up with a helper function that checks if first is ever equal to last before it reaches the end of the container. If true, it's a strong guarantee that first does not come after last and therefore the range is valid.

template <typename Iterator>
bool isValidRange(Iterator first, Iterator last, Iterator end)
{
  for (; first != end; ++first)
    if (first == last) return true;
  return false;
}

It's not very convenient because you have to pass it an iterator to the end of the container in addition to the iterators that specify the range.

Is this correct? Is there a better way to do this?

Answer 1

how can we check if a range is valid?

You can't. Your function cannot guarantee that the range is valid, only that the last is reachable from the first. These are two different things (for a simple example, consider an iterator into a vector which was subsequently reallocated). There is no mechanism by Standard that permits you to check if a range is valid. Much like you cannot know that a pointer is valid before you de-reference it.

Just to note, Microsoft provided a function to check if a pointer was valid and it utterly screwed everyone who used it. Raymond Chen said that it should have been named CorruptMemoryIfPossible.

Answer 2

[iterator.requirements.general] defines the "valid range" term:

10 A sentinel s is called reachable from an iterator i if and only if there is a finite sequence of applications of the expression ++i that makes i == s. If s is reachable from i, [i, s) denotes a valid range.

So "last is reachable from the first" is exactly equal to "valid range" definition from the standard PoV (and hence for UB definition). Dereferencability of iterators is orthogonal to this definition.