以下代码(执行跨子对象边界的指针算术)是否对其编译的类型 T(在 C++11 中为 does not not necessarily have to be POD)或任何类型具有明确定义的行为子集？

#include <cassert>
#include <cstddef>

template<typename T>
struct Base
{
    // ensure alignment
    union
    {
        T initial;
        char begin;
    };
};

template<typename T, size_t N>
struct Derived : public Base<T>
{
    T rest[N - 1];
    char end;
};

int main()
{
    Derived<float, 10> d;
    assert(&d.rest[9] - &d.initial == 10);
    assert(&d.end - &d.begin == sizeof(float) * 10);
    return 0;
}

LLVM 在内部 vector 类型的实现中使用了上述技术的变体，该内部 vector 类型经过优化，最初将堆栈用于小型数组，但一旦超过初始容量，就会切换到堆分配的缓冲区。 (从这个例子中并不清楚这样做的原因，但显然是为了减少模板代码膨胀；如果你看一下 code 会更清楚。)

注意:在任何人提示之前，这并不是他们正在做的事情，可能他们的方法比我在这里给出的更符合标准，但我想问一下一般情况。

显然，它在实践中有效，但我很好奇标准中是否有任何内容可以保证这种情况。我倾向于拒绝，因为 N3242/expr.add:

When two pointers to elements of the same array object are subtracted, the result is the difference of the subscripts of the two array elements...Moreover, if the expression P points either to an element of an array object or one past the last element of an array object, and the expression Q points to the last element of the same array object, the expression ((Q)+1)-(P) has the same value as ((Q)-(P))+1 and as -((P)-((Q)+1)), and has the value zero if the expression P points one past the last element of the array object, even though the expression (Q)+1 does not point to an element of the array object. ...Unless both pointers point to elements of the same array object, or one past the last element of the array object, the behavior is undefined.

但理论上，上述引用的中间部分，结合类布局和对齐保证，可能允许以下(次要)调整有效:

#include <cassert>
#include <cstddef>

template<typename T>
struct Base
{
    T initial[1];
};

template<typename T, size_t N>
struct Derived : public Base<T>
{
    T rest[N - 1];
};

int main()
{
    Derived<float, 10> d;
    assert(&d.rest[9] - &d.rest[0] == 9);
    assert(&d.rest[0] == &d.initial[1]);
    assert(&d.rest[0] - &d.initial[0] == 1);
    return 0;
}

结合其他关于 union 布局、与 char * 之间的可转换性等的规定，可以说使原始代码也有效。 (主要问题是上面给出的指针算术定义缺乏传递性。)

有人知道吗？ N3242/expr.add 似乎明确指出指针必须属于同一个“数组对象”才能对其进行定义，但 可能 假设其他保证的情况在标准中，当组合在一起时，在这种情况下可能无论如何都需要一个定义，以保持逻辑上的自洽。 (我不赌它，但我认为它至少是可以想象的。)

编辑:@MatthieuM 提出了这个类不是标准布局的反对意见，因此可能不能保证在基子对象和派生的第一个成员之间不包含任何填充，即使两者与 alignof(T) 对齐。我不确定这是多么真实，但这会引发以下变体问题:

• 如果继承被删除，这是否可以保证工作？

• 是否保证 &d.end - &d.begin >= sizeof(float) * 10 即使 &d.end - &d.begin == sizeof(float) * 10 不是？

LAST EDIT @ArneMertz 主张非常仔细地阅读 N3242/expr.add(是的，我知道我正在阅读草稿，但已经足够接近了) ，但是如果删除交换线，标准是否真的暗示以下具有未定义的行为？ (与上述相同的类定义)

int main()
{
    Derived<float, 10> d;
    bool aligned;
    float * p = &d.initial[0], * q = &d.rest[0];

    ++p;
    if((aligned = (p == q)))
    {
        std::swap(p, q); // does it matter if this line is removed?
        *++p = 1.0;
    }

    assert(!aligned || d.rest[1] == 1.0);

    return 0;
}

另外，如果 == 不够强大，如果我们利用 std::less 形成指针的全序这一事实，并更改以上条件为:

    if((aligned = (!std::less<float *>()(p, q) && !std::less<float *>()(q, p))))

根据严格阅读标准，假设两个相等指针指向同一个数组对象的代码真的被破坏了吗？

编辑抱歉，只想再添加一个示例，以消除标准布局问题:

#include <cassert>
#include <cstddef>
#include <utility>
#include <functional>

// standard layout
struct Base
{
    float initial[1];
    float rest[9];
};

int main()
{
    Base b;
    bool aligned;
    float * p = &b.initial[0], * q = &b.rest[0];

    ++p;
    if((aligned = (p == q)))
    {
        std::swap(p, q); // does it matter if this line is removed?
        *++p = 1.0;
        q = &b.rest[1];
        // std::swap(p, q); // does it matter if this line is added?
        p -= 2; // is this UB?
    }
    assert(!aligned || b.rest[1] == 1.0);
    assert(p == &b.initial[0]);

    return 0;
}

最佳答案

更新:这个答案起初遗漏了一些信息，因此导致错误的结论。

在您的示例中，initial和 rest是明显不同的(数组)对象，因此比较指向 initial 的指针(或其元素)带有指向 rest 的指针(或其元素)是

• UB，如果你使用指针的差异。 (§5.7,6)
• 未指定，如果您使用关系运算符(第 5.9,2 节)
• 为== 定义明确(所以第二次剪断很好，见下文)

第一个片段:

在第一个片段中建立差异是未定义的行为，对于您提供的报价(§5.7,6):

Unless both pointers point to elements of the same array object, or one past the last element of the array object, the behavior is undefined.

澄清第一个示例代码的UB部分:

//first example
int main()
{
    Derived<float, 10> d;
    assert(&d.rest[9] - &d.initial == 10);            //!!! UB !!!
    assert(&d.end - &d.begin == sizeof(float) * 10);  //!!! UB !!! (*)
    return 0;
}

标有 (*) 的行很有趣:d.begin和 d.end不是同一数组的元素，因此运算结果为 UB。尽管您可以 reinterpret_cast<char*>(&d)并将它们的地址都放在结果数组中。但由于该数组是 d 的 all 的表示形式。 , 不应被视为对 d 的部分的访问。 .因此，虽然该操作可能会正常工作并在任何人梦寐以求的实现中给出预期结果，但它仍然是 UB - 作为定义问题。

第二个片段:

这实际上是定义良好的行为，但实现定义的结果:

int main()
{
    Derived<float, 10> d;
    assert(&d.rest[9] - &d.rest[0] == 9);
    assert(&d.rest[0] == &d.initial[1]);         //(!)
    assert(&d.initial[1] - &d.initial[0] == 1);
    return 0;
}

标有 (!) 的行不是 ub，但它的结果是实现定义，因为填充、对齐和提到的工具可能会起作用。 但是如果该断言成立，您可以像使用一个数组一样使用两个对象部分。

你会知道 rest[0]将在 initial[0] 之后立即铺设在内存中。 乍一看，你不能轻易使用等式:

• initial[1]将指向 initial 的末尾, 取消引用它是 UB。
• rest[-1]明显超出范围。

但进入§3.9.2,3:

If an object of type T is located at an address A, a pointer of type cv T* whose value is the address A is said to point to that object, regardless of how the value was obtained. [ Note: For instance, the address one past the end of an array (5.7) would be considered to point to an unrelated object of the array’s element type that might be located at that address.

只要 &initial[1] == &rest[0] ，它将是二进制的，就好像只有一个数组一样，一切都会好的。

您可以遍历两个数组，因为您可以在边界处应用一些“指针上下文切换”。所以对于你的最后一个片段:swap不需要!

但是，有一些注意事项:rest[-1]是 UB，所以 initial[2] ，因为 §5.7,5:

If both the pointer operand and the result point to elements of the same array object, or one past the last element of the array object, the evaluation shall not produce an overflow; otherwise, the behavior is undefined.

(强调我的)。那么这两者如何结合在一起呢？

• “好路”:&initial[1]没问题，因为 &initial[1] == &rest[0]您可以获取该地址并继续增加指针以访问 rest 的其他元素, 因为 §3.9.2,3
• “错误路径”:initial[2]是 *(initial + 2) , 但由于 §5.7,5, initial +2已经是 UB，您永远无法在此处使用 §3.9.2,3。

一起:你必须在边界停下来，稍作休息以检查地址是否相等，然后你可以继续前进。

关于c++ - 跨子对象边界的指针算法，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/15217572/