为什么标准迭代器范围是[begin，end]而不是[begin，end]？

为什么将标准定义end()为末尾而不是末尾？

最好的论据是Dijkstra本人提出的：

• 你想要的范围的大小是一个简单的区别结束  -  开始 ;

• 当序列退化为空序列时，包含下界更“自然”，并且还因为替代方案（不包括下界）将需要存在“一个从头开始”的前哨值。

您仍然需要说明为什么从零开始而不是从1开始计数，但这不是问题的一部分。

[begin，end）约定背后的智慧一次又一次地获得回报，当您拥有某种类型的算法来处理对基于范围的构造的多个嵌套或迭代调用时，这种调用自然会链接。相比之下，使用双封闭范围会产生异样的结果以及极其不愉快和嘈杂的代码。例如，考虑分区[ n ₀，n ₁ ] [ n ₁，n ₂）[ n ₂，n ₃）。另一个例子是标准迭代循环for (it = begin; it != end; ++it)，它运行end - begin时间。如果两端都包含在内，则相应的代码将不那么易读-想象一下如何处理空范围。

最后，我们还可以做出一个很好的论证，为什么计数应从零开始：对于刚刚建立的范围，采用半开式约定，如果给定N个元素的范围（例如，枚举数组的成员），则0是自然的“开始”，因此您可以将范围写为[0，N），而无需任何笨拙的偏移或校正。

简而言之：在1基于范围的算法中我们没有看到数字的事实是[begin，end）约定的直接结果和动机。

其实，很多的迭代器相关的东西突然更有道理，如果你考虑不迭代器指向在该序列的元素，但在两者之间，与非关联访问的下一个元素的权利吧。然后，“ one end end”迭代器突然变得有意义：

   +---+---+---+---+
   | A | B | C | D |
   +---+---+---+---+
   ^               ^
   |               |
 begin            end

显然begin指向序列的开头，并end指向同一序列的结尾。取消引用begin访问element A，并且取消引用end没有意义，因为没有元素权限。另外，i在中间添加一个迭代器

   +---+---+---+---+
   | A | B | C | D |
   +---+---+---+---+
   ^       ^       ^
   |       |       |
 begin     i      end

并且您立即看到元素范围从begin到i包含元素A，B而元素范围从i到end包含元素C和D。解引用i赋予其元素权利，即第二个序列的第一个元素。

甚至反向迭代器的“一对一”也突然变得很明显：反向序列可以得出：

   +---+---+---+---+
   | D | C | B | A |
   +---+---+---+---+
   ^       ^       ^
   |       |       |
rbegin     ri     rend
 (end)    (i)   (begin)

我在下面的括号中编写了相应的非反向（基本）迭代器。您会看到，属于i（我已经命名为ri）的反向迭代器仍指向元素B和之间C。但是由于反转顺序，现在元素B在它的右边。

为什么将标准定义end()为末尾而不是末尾？

因为：

1. 避免对空范围进行特殊处理。对于空范围，begin()等于 end()＆
2. 对于循环遍历元素的循环，它使结束条件变得简单：只要end()没有达到，循环就继续下去。

因为那

size() == end() - begin()   // For iterators for whom subtraction is valid

而且您不必做诸如此类的尴尬事情

// Never mind that this is INVALID for input iterators...
bool empty() { return begin() == end() + 1; }

而且您不会意外地编写错误的代码，例如

bool empty() { return begin() == end() - 1; }    // a typo from the first version
                                                 // of this post
                                                 // (see, it really is confusing)

bool empty() { return end() - begin() == -1; }   // Signed/unsigned mismatch
// Plus the fact that subtracting is also invalid for many iterators

另外：如果指向有效元素，将find()返回什么end()？
您是否真的想要另一个成员invalid()返回无效的迭代器？
两个迭代器已经足够痛苦了……

哦，请参阅此相关文章。

也：

如果在end最后一个元素之前，您将如何insert()走到最后呢？

半封闭范围的迭代器习惯用法[begin(), end())最初基于纯数组的指针算法。在这种操作模式下，您将具有传递了数组和大小的函数。

void func(int* array, size_t size)

[begin, end)当您具有以下信息时，转换为半封闭范围非常简单：

int* begin;
int* end = array + size;

for (int* it = begin; it < end; ++it) { ... }

要使用全封闭范围，则比较困难：

int* begin;
int* end = array + size - 1;

for (int* it = begin; it <= end; ++it) { ... }

由于指向数组的指针是C ++中的迭代器（并且语法被设计为允许这样做），所以调用起来std::find(array, array + size, some_value)要比调用起来容易得多std::find(array, array + size - 1, some_value)。

另外，如果您使用半封闭范围，则可以使用!=运算符检查结束条件，因为（如果运算符定义正确）<暗含!=。

for (int* it = begin; it != end; ++ it) { ... }

但是，没有简单的方法可以对全封闭范围执行此操作。你被困住了<=。

在C ++中唯一支持<和>操作的迭代器是随机访问迭代器。如果您必须为<=C ++中的每个迭代器类编写一个运算符，则必须使所有迭代器具有完全可比性，并且创建功能较弱的迭代器（如on上的双向迭代器std::list或输入迭代器）的选择更少。iostreams如果C ++使用的是全封闭范围，则对进行操作）。

通过将end()指针指向末尾，很容易使用for循环来迭代一个集合：

for (iterator it = collection.begin(); it != collection.end(); it++)
{
    DoStuff(*it);
}

随着end()指向最后一个元素，一个循环会更复杂：

iterator it = collection.begin();
while (!collection.empty())
{
    DoStuff(*it);

    if (it == collection.end())
        break;

    it++;
}

1. 如果容器是空的， begin() == end()。
2. C ++程序员倾向于在循环条件下使用!=而不是<（少于），因此，将end()指针指向一个末端是方便的。