通过下标获取一个最后一个数组元素的地址：是否符合C ++标准？

int array[5];
int *array_begin = &array[0];
int *array_end = &array[5];

#1 楼

您的示例是合法的，但这仅是因为您实际上并未使用界外指针。

首先让我们处理界外指针（因为这是我最初解释您的问题的方式，然后我才注意到该示例改为使用一个过去的指针）：

通常，甚至不允许您创建越界指针。指针必须指向数组中的一个元素，或者指向末尾的一个元素。

甚至不允许指针存在，这显然也不允许您取消引用它。

这是标准中必须说明的主题：

5.7：5：


当将具有整数
类型的表达式添加到
指针或从中减去时，结果的类型为
指针操作数。如果指针
操作数指向
数组对象的元素，并且数组足够大
，则结果指向从原始
偏移的
元素元素，使得结果数组元素和
原始数组元素的下标之差等于
整数表达式。换句话说，如果表达式P指向数组对象的第i个
元素，则
表达式（P）+ N（相当于，
N +（P） ）和（P）-N（其中N具有
值n）分别指向
数组对象的第i + n个元素和第i-n个元素，
此外，如果表达式P指向数组的最后一个元素
，则表达式（P）+1指向数组的最后一个元素一个数组
对象，如果表达式Q指向
数组的最后一个元素之后
，则表达式（Q）-1指向
该数组的最后一个元素数组对象。
如果指针操作数和
结果都指向同一
数组对象的元素，或者指向最后一个元素
数组对象的元素，
求值不应产生
溢出；否则，行为是未定义的。


（强调我的）

当然，这是针对operator +的。因此，可以肯定的是，这是标准关于数组下标的内容：

5.2.1：1：


表达式E1[E2]是相同的（按定义）到*((E1)+(E2))


当然，有一个明显的警告：您的示例实际上并未显示越界指针。它使用“结束后一个”指针，这是不同的。允许指针存在（如上所述），但是据我所知，标准没有提及取消引用。我能找到的最接近的是3.9.2：3：


[注意：例如，将数组末尾的地址（5.7）视为
指向数组元素类型的不相关对象，该对象可能位于该地址。 —尾注]


在我看来，是的，您可以合法地取消引用它，但未指定读取或写入该位置的结果。

感谢ilproxyil在这里纠正了最后一点，回答了问题的最后一部分：



array + 5实际上并没有取消引用任何东西，它只是简单地
创建指向array末尾的指针。

&array[4] + 1取消引用
array+4（非常安全），
采用该地址左值，并向该地址添加一个
，该地址
导致最后一个指针
（但该指针永远不会被取消引用。

&array[5]取消引用array + 5
（据我所知，这是合法的，
导致“数组元素类型的不相关对象
”，作为
以上所述），然后采用该元素的
地址，这也很合法。

因此，他们做的事情并不完全相同，尽管在这种情况下，最终结果是相同的。

#2 楼

是的，这是合法的。根据C99标准草案：

第6.5.2.1节第2段：


后缀表达式和方括号[]中的表达式是带下标的
数组对象元素的指定。下标运算符[]
的定义是E1[E2]与(*((E1)+(E2)))相同。由于
适用于二进制+运算符的转换规则，如果E1是数组对象（相当于指向数组对象的
初始元素的指针），而E2是整数，则E1[E2]指定E2 -th
E1的元素（从零开始计数）。


第6.5.3.2节，第3段（重点是我的）：


一元&运算符产生其操作数的地址。如果操作数的类型为“类型”，
结果的类型为“类型的指针”。如果操作数是一元*运算符的结果，则
不对该运算符和&运算符进行求值，并且结果似乎都被省略了，只是对运算符的约束仍然适用并且结果不是
左值。同样，如果操作数是[]运算符的结果，则不会对＆运算符或*所隐含的一元[]求值，并且结果就像删除了&运算符
并更改了[]运算符一样给+运算符。否则，结果是
指向由其操作数指定的对象或函数的指针。


第6.5.6节第8段：


将具有整数类型的表达式添加到指针或从指针中减去时，
结果具有指针操作数的类型。如果指针操作数指向
数组对象的元素，并且数组足够大，则结果指向距
的元素偏移量原始元素，以使结果数组元素和原始
数组元素的下标之差等于整数表达式。换句话说，如果表达式P指向数组对象的第i个元素，则表达式(P)+N（等效为N+(P)）和
(P)-N（其中N具有值n）分别指向，
数组对象的第i+n个元素和第i−n个元素（如果存在）。此外，如果表达式P指向数组对象的last (P)+1指向一个数组对象的最后一个元素，如果表达式Q指向一个数组对象的最后一个元素。一个数组对象，表达式(Q)-1指向数组对象的最后一个元素。如果指针
操作数和结果都指向同一数组对象的元素，或者指向数组对象的最后一个
元素之后，则评估不应产生溢出；否则，
行为是不确定的。如果结果指向数组对象的最后一个元素，则它
不能用作被评估的一元*运算符的操作数。


如果未取消引用，则标准明确允许指针指向数组末尾的一个元素。在6.5.2.1和6.5.3.2中，表达式&array[5]等效于&*(array + 5)，等效于(array+5)，后者指向数组末尾。这不会导致取消引用（按6.5.3.2），因此是合法的。

评论

---

他明确询问了C ++。这是在两者之间移植时不能依靠的细微差别。

–马修·弗拉申（Matthew Flaschen）
09年6月12日在21:34

---

他问了两个问题：“知道它是否符合C标准也很有趣。”

– CB Bailey
09年6月12日在21:42

---

@Matthew Flaschen：C ++标准通过引用合并了C标准。附件C.2包含更改列表（ISO C和ISO C ++之间的不兼容性），并且所有更改均与这些条款无关。因此，＆array [5]在C和C ++中是合法的。

–亚当·罗森菲尔德
09年6月12日在22:00

---

C标准是C ++标准中的规范性参考。这意味着C ++标准引用的C标准条款是C ++标准的一部分。这并不意味着C标准中的所有内容都适用。特别是附件C是提供信息的，不是规范性的，因此，仅因为本节中未突出显示差异并不意味着C“版本”适用于C ++。

– CB Bailey
09年6月12日在22:20

---

@亚当：谢谢你指出这一点。我从未完全确定C的历史。关于C ++ 0x，指的是C99，我对C99的更改知之甚少，我很确定C ++会继续参考C89 / 90，并且会逐案挑选C99的“理想”更改。这个问题/答案就是一个很好的例子。我想说C ++将继续使用“从左值到右值”（novalue-to-rvalue），因此没有未定义的行为，而不是集成“＆* == no-op”的措辞。

–理查德·科登（Richard Corden）
09年6月17日在7:49

---

#3 楼

这是合法的。

根据C ++的gcc文档，&array[5]是合法的。在C ++和C语言中，您都可以安全地在数组末尾寻址该元素-您将获得一个有效的指针。因此，将&array[5]作为表达式是合法的。因此，即使指针本身有效，尝试取消引用由该表达式生成的指针仍然是未定义的行为（即非法）。

实际上，我认为它通常不会导致崩溃。 br />
编辑：顺便说一句，这通常是实现STL容器的end（）迭代器的方式（作为指向过去的指针），因此这是对实践的很好证明是合法的。

编辑：哦，现在我看到您不是真正在问持有指向该地址的指针是否合法，但是获取指针的确切方法是否合法。我会请其他回答者来回答。

#4 楼

我认为这是合法的，并且取决于发生的“从左值到右值”的转换。最后一行核心问题232具有以下内容：我们同意该标准中的方法似乎还可以：p = 0; * p;本质上不是错误。从左值到右值的转换会带来不确定的行为


尽管这是一个稍有不同的示例，但它确实表明，'*'不会导致左值到右值的转换，并且因此，假设表达式是'＆'的直接操作数，且期望该值是一个左值，则定义行为。

#5 楼

我不认为这是非法的，但我确实认为＆array [5]的行为未定义。


5.2.1 [expr.sub] E1 [E2]是（根据定义）与*（（E1）+（E2））相同。
5.3.1 [expr.unary.op]一元*运算符...结果是一个左值，它引用对象或函数。表达式点。

此时，您有未定义的行为，因为表达式（（E1）+（E2））并未实际指向对象，并且标准确实指出了结果应该是什么，除非它

1.3.12 [defns.undefined]当本国际标准省略任何对行为的明确定义的描述时，也可能会出现未定义的行为。

如其他地方所述，array + 5和&array[0] + 5是获得数组末尾一个指针的有效且定义明确的方法。

#6 楼

除了上述答案外，我还指出了可以将operator＆覆盖为类。因此，即使它对POD有效，对您知道无效的对象也不是一个好主意（就像首先覆盖了operator＆（）一样。）。

#7 楼

这是合法的：

int array[5];
int *array_begin = &array[0];
int *array_end = &array[5];

第5.2.1节下标表达式E1 [E2]（通过定义）与*（（E1）+（ E2））


因此，我们可以说array_end也等效：

int *array_end = &(*((array) + 5)); // or &(*(array + 5))

5.3节.1.1一元运算符'*'：一元*运算符执行间接操作：对其应用的表达式应为指向对象类型的指针，或为
指向函数类型的指针，并且结果为引用的左值表达式指向的对象或函数。
如果表达式的类型为“指向T的指针”，则结果的类型为“ T”。 [注意：指向不完整类型（cv void以外的
）的指针可以被取消引用。这样获得的左值可以以有限的方式使用（以初始化引用为例）。此左值不能转换为右值，请参见4.1。 —结束语]


上面重要的部分：


'结果是引用对象或函数的左值'。 br />

一元运算符'*'返回一个引用int的左值（无反引用）。一元运算符'＆'然后获取左值的地址。

，只要不取消对超出范围的指针的引用，该操作就被标准完全覆盖，并且所有行为定义。因此，根据我的阅读，以上内容完全合法。

许多STL算法都依赖于行为定义良好的事实，这暗示着标准委员会已经做到了这一点，并且我肯定有一个明确地涵盖了这一点的东西。

下面的注释部分提出了两个参数：

（请阅读：但是它很长，我们俩都最终trollish）

参数1

由于第5.7条第5款的规定，这是非法的


当将具有整数类型的表达式添加到指针或从指针中减去时，结果将具有指针操作数的类型。如果指针操作数指向数组对象的元素，并且数组足够大，则结果指向与原始元素偏移的元素，以使结果数组元素和原始数组元素的下标之差等于整数表达式。换句话说，如果表达式P指向数组对象的第i个元素，则表达式（P）+ N（相当于N +（P））和（P）-N（其中N的值为n）到数组对象的第i + n个元素和第i-n个元素，只要它们存在。此外，如果表达式P指向数组对象的最后一个元素，则表达式（P）+1指向数组对象的最后一个元素之后，如果表达式Q指向数组对象的最后一个元素之后，表达式（Q）-1指向数组对象的最后一个元素。如果指针操作数和结果都指向同一数组对象的元素，或者指向数组对象的最后一个元素，则求值不会产生溢出；


并且尽管该节是相关的；否则，该行为是不确定的。它不会显示未定义的行为。我们正在讨论的数组中的所有元素都在数组中，或者在末尾（在上面的段落中已定义）。

论点2：

下面显示的第二个参数是：*是取消引用运算符。
尽管这是用于描述'*'运算符的常用术语；在标准中故意避免使用此术语，因为术语“取消引用”在语言以及对底层硬件的含义方面定义不充分。

尽管访问超出数组末尾的内存绝对是未定义的行为。我不相信unary * operator在这种情况下（不是按照标准定义的方式）访问内存（对内存的读/写）。在这种情况下（如标准所定义（请参阅5.3.1.1）），unary * operator返回lvalue referring to the object。在我对语言的理解中，这不是访问基础内存。然后，该表达式的结果立即由unary & operator运算符使用，该运算符返回lvalue referring to the object所引用的对象的地址。

还提供了许多其他有关Wikipedia和非规范资源的参考。我发现所有这些都不相关。 C ++是由标准定义的。 。以下提供了NON。如果您给我看一个显示这是UB的标准参考书。我会


留下答案。
大写这是愚蠢的，我所有人都读错了。参数：


并非全世界都由C ++标准定义。敞开心mind。

#8 楼

工作草案（n2798）：“一元＆运算符的结果是一个指向其操作数的指针。操作数
应为左值或限定值-id。
在第一种情况下，如果
表达式的类型为“ T”，则
结果的类型为“指向T的指针”。（第103页）


array [5]并不是我所能分辨的合格ID（列表在第87页）；最接近的似乎是标识符，但是当array是标识符时，array [5]不是。它不是左值，因为“左值是指对象或函数。”（第76页）。 array [5]显然不是函数，并且不能保证引用有效对象（因为array + 5在最后分配的数组元素之后）。

显然，它在某些情况下可能有效，但它不是有效的C ++或安全代码。

注意：合法的是通过数组加一（p。113）：


表达式P [指针]
指向数组的最后一个元素
，表达式（P）+1指向
指向数组的最后一个元素
，并且如果表达式Q指向
数组的最后一个元素
，则表达式（Q）-1指向
数组对象的最后一个元素。
如果指针操作数和
结果都指向同一个
数组对象的元素，或者指向数组对象的最后一个
元素之后的元素，则
求值不应产生
溢出”


但是使用＆。这样做是不合法的。

#9 楼

即使合法，为什么还要违背约定？数组+ 5无论如何都更短，而且我认为可读性更高。

编辑：如果希望通过对称方式实现，则可以编写

int* array_begin = array; 
int* array_end = array + 5;

#10 楼

出于以下原因，它应该是未定义的行为：


尝试访问越界元素会导致未定义的行为。因此，在这种情况下，标准不禁止实现抛出异常（即，在访问元素之前检查边界的实现）。如果将& (array[size])定义为begin (array) + size，则在越界访问的情况下抛出异常的实现将不再符合标准。
如果array不是数组而是一个数组，则无法产生end (array)的产量。任意集合类型。

#11 楼

C ++标准5.19，第4段：

地址常量表达式是指向左值的指针...。该指针应使用一元＆运算符或使用数组（4.2）...类型下标运算符[] ...可以用于创建地址常量表达式，但是不能通过使用这些运算符来访问对象的值。如果使用下标运算符，则其操作数之一应为整数常量表达式。

对我来说，＆array [5]是合法的C ++，是地址常量表达式。

#12 楼

如果您的示例不是一般情况，而是特定情况，则可以使用。您可以合法地通过AFAIK将内存移动到分配的内存块之外。
它不适用于一般情况，例如，当您尝试访问距离数组结尾较远1的元素时。

仅搜索C-Faq：链接文本

#13 楼

这是完全合法的。

当调用myVec.end（）时，来自stl的vector <>模板类正是这样做的：它为您提供了一个指针（在此为迭代器），该指针指向数组末尾的一个元素。