自C ++ 17起，具有正确地址和类型的指针仍然始终是有效的指针吗？

_{（参考此问答）。}

在C ++ 17标准之前，[basic.compound] / 3中包含以下句子：

如果类型T的对象位于地址A，则将其值为地址A的cv T *类型的指针指向该对象，而不管如何获取该值。

但是从C ++ 17开始，此句子已删除。

例如，我相信这句话使此示例代码已定义，并且由于C ++ 17，这是未定义的行为：

 alignas(int) unsigned char buffer[2*sizeof(int)];
 auto p1=new(buffer) int{};
 auto p2=new(p1+1) int{};
 *(p1+1)=10;

在C ++ 17之前，p1+1持有的地址*p2并具有正确的类型，因此*(p1+1)是的指针*p2。在C ++ 17p1+1中，指针是一个end-the-end，因此它不是指向对象的指针，并且我相信它是不可引用的。

是对标准权利的这种修改的解释，还是有其他规则可以补偿所引用句子的删除？

是对标准权利的这种修改的解释，还是有其他规则可以弥补对被引句子的删除？

是的，这种解释是正确的。末尾的指针不能简单地转换为恰好指向该地址的另一个指针值。

新的[basic.compound] / 3说：

指针类型的每个值都是以下值之一：
（3.1）指向对象或函数的指针（据说该指针指向该对象或函数），或
（3.2）超出对象末尾的指针（[expr .add]），或

这些是互斥的。p1+1是末尾的指针，而不是对象的指针。p1+1指向x[1]一个大小为1的数组的假设p1，而不是p2。这两个对象不是指针可互换的。

我们还有非规范性注释：

[注意：超出对象末尾的指针（[expr.add]）不会被认为指向可能位于该地址的对象类型的不相关对象。[...]

这澄清了意图。

正如TC在众多评论中指出的那样（特别是这一点），这确实是尝试实现问题的一种特例std::vector-这[v.data(), v.data() + v.size())需要是一个有效范围，但vector不会创建数组对象，因此只有定义的指针算法才能从向量中的任何给定对象到其假设的一维数组的末尾。有关更多资源，请参见CWG 2182，此标准讨论以及有关该主题的论文的两个修订版：P0593R0和P0593R1（特别是第1.3节）。

在您的示例中，*(p1 + 1) = 10;应该为UB，因为它在大小为1的数组的末尾一个。但是在这里，我们处于一种非常特殊的情况，因为该数组是在较大的char数组中动态构造的。

动态对象创建在C ++标准的n4659草案的C ++对象模型[intro.object] §3中进行了描述：

3如果在与另一个对象“ e的类型为N个无符号字符的数组”或类型为“ N个std :: byte的数组”（21.2.1）的另一个对象e相关联的存储中创建了完整对象（8.3.4），则该数组将提供存储空间对于创建的对象，如果：
（3.1）-e的生存期已经开始并且没有结束，并且
（3.2）-新对象的存储完全适合e，并且
（3.3）-没有更小的数组对象可以满足这些要求约束。

3.3似乎还不清楚，但是下面的示例使意图更加清楚：

struct A { unsigned char a[32]; };
struct B { unsigned char b[16]; };
A a;
B *b = new (a.a + 8) B; // a.a provides storage for *b
int *p = new (b->b + 4) int; // b->b provides storage for *p
// a.a does not provide storage for *p (directly),
// but *p is nested within a (see below)

因此，在该示例中，buffer阵列提供存储两个*p1和*p2。

下面的段落证明，两个完整的对象*p1，并*p2为buffer：

4如果满足以下条件，则对象a嵌套在另一个对象b中：
（4.1）— a是b的子对象，或者
（4.2）— b为a提供存储，或者
（4.3）—存在对象c，其中a嵌套在c中，并且c嵌套在b中。

5对于每个对象x，都有一些称为x的完整对象的对象，确定如下：
（5.1）-如果x是一个完整对象，则x的完整对象本身就是它。
（5.2）—否则，x的完整对象是包含x的（唯一）对象的完整对象。

一旦确定，C ++ 17的n4659草案的其他相关部分为[basic.coumpound]§3（强调我的）：

3 ...指针类型的每个值都是以下值之一：
（3.1）-指向对象或函数的指针（据说该指针指向该对象或函数），或
（3.2）-末尾的指针对象（8.7）或
（3.3）-该类型的空指针值（7.11），或
（3.4）-无效的指针值。

这是一个指向或过去的对象的端部的指针类型的值表示在存储器中（4.4）的第一个字节的地址对象所占用的存储结束后在内存中或第一字节 占用由对象， 分别。[注意：超出对象末尾的指针（8.7）不会被认为指向不相关的指针可能位于该地址的对象类型的对象。当指针值表示的存储到达存储持续时间的结尾时，该指针值将变为无效；参见6.7。—尾注]出于指针算术（8.7）和比较（8.9，8.10）的目的，超过n个元素的数组x的最后一个元素的末尾的指针被视为等效于指向假设元素x [的指针] n]。指针类型的值表示形式是实现定义的。指向布局兼容类型的指针应具有相同的值表示和对齐要求（6.11）...

该说明指针过去的结束......在这里并不适用，因为对象的指向p1和p2不无关系，但嵌套到同一个完整的对象，所以指针算术使物体内部的感觉，提供存储：p2 - p1定义，是(&buffer[sizeof(int)] - buffer]) / sizeof(int)那是1。

因此p1 + 1 是的指针*p2，并*(p1 + 1) = 10;已定义行为并设置的值*p2。

我还阅读了有关C ++ 14和当前（C ++ 17）标准之间兼容性的C4附件。消除在单个字符数组中动态创建的对象之间使用指针算法的可能性将是IMHO应该在此处引用的一项重要更改，因为它是常用的功能。由于兼容性页面中没有关于它的内容，我认为它确认该标准不是禁止它的意图。

特别是，它将破坏没有默认构造函数的类中对象数组的常见动态构造：

class T {
    ...
    public T(U initialization) {
        ...
    }
};
...
unsigned char *mem = new unsigned char[N * sizeof(T)];
T * arr = reinterpret_cast<T*>(mem); // See the array as an array of N T
for (i=0; i<N; i++) {
    U u(...);
    new(arr + i) T(u);
}

arr 然后可以用作指向数组第一个元素的指针...

为了扩大此处给出的答案，我认为修改后的措词不包括以下示例：

警告：未定义的行为

#include <iostream>
int main() {
    int A[1]{7};
    int B[1]{10};
    bool same{(B)==(A+1)};

    std::cout<<B<< ' '<< A <<' '<<sizeof(*A)<<'\n';
    std::cout<<(same?"same":"not same")<<'\n';
    std::cout<<*(A+1)<<'\n';//!!!!!  
    return 0;
}

出于完全依赖于实现（且脆弱）的原因，该程序的可能输出为：

0x7fff1e4f2a64 0x7fff1e4f2a60 4
same
10

该输出表明，这两个数组（在这种情况下）恰好存储在内存中，使得的“一个结尾”A恰好保存的第一个元素的地址值B。

修订后的规范可确保无论如何A+1永远都不是指向的有效指针B。古老的短语“不管如何获取值”都说，如果“ A + 1”恰好指向“ B [0]”，则它是指向“ B [0]”的有效指针。那不可能是好事，而且肯定不会是意图。