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

Question

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

Answer 1

最好的论据很容易是Dijkstra himself提出的论据：

• 你希望范围的大小是一个简单的差异end - begin;

• 当序列退化为空序列时，包含下限更“自然”，而且因为替代方案（排除下限）需要存在“one-before” -the-beginning" 标记值。

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

当您拥有任何类型的算法来处理对基于范围的构造的多个嵌套或迭代调用时，[begin, end) 约定背后的智慧一次又一次地得到回报，这些构造自然地链接在一起。相比之下，使用双重封闭的范围会导致错误和非常不愉快和嘈杂的代码。例如，考虑一个分区 [n₀, n₁)[n ₁, n₂)[n₂,n em>₃）。另一个例子是标准迭代循环for (it = begin; it != end; ++it)，它运行end - begin 次。如果两端都包含在内，则相应的代码的可读性会大大降低——想象一下您将如何处理空范围。

最后，我们还可以提出一个很好的论据，为什么计数应该从零开始：根据我们刚刚建立的范围的半开约定，如果给定一个 N 个元素的范围（比如枚举数组的成员），然后 0 是自然的“开始”，因此您可以将范围写为 [0, N)，没有任何尴尬的偏移或更正。

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

Answer 2

实际上，如果考虑到迭代器不是指向 序列的元素而是 位于它们之间，那么很多与迭代器相关的东西突然变得更有意义了，通过解引用访问下一个元素。然后“过去的结束”迭代器突然变得有意义：

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

显然begin指向序列的开头，end指向同一个序列的结尾。取消引用begin 会访问元素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 在它的右边。

Answer 3

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

因为：

1. 它避免了对空范围的特殊处理。对于空范围，begin() 等于 end() &
2. 它使迭代元素的循环的结束标准变得简单：循环简单 只要没有达到end()，就继续。

Answer 4

因为那时

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

另外：如果end() 指向一个有效元素，find() 会返回什么？
你真的想要另一个名为invalid()的成员返回一个无效的迭代器吗？！
两个迭代器已经够痛苦了……

哦，还有查看this相关帖子。

---

还有：

如果end在最后一个元素之前，你会如何insert()在真正的结尾？！

Answer 5

半封闭范围[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++ 中的每个迭代器类编写 <= 运算符，则必须使所有迭代器完全可比，并且创建功能较差的迭代器的选择更少（例如 @987654336 上的双向迭代器@，或在 iostreams) 上运行的输入迭代器（如果 C++ 使用全封闭范围）。

Answer 6

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++;
}

Answer 7

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