是否比较两个 void 指针到 C++ 中定义的不同对象？

发布于 2024-12-17 12:58:03 字数 618 浏览 2 评论 0原文

受到关于动态转换为 void* 的这个答案的启发：

<前><代码>... 布尔 eqdc(B* b1, B *b2) { 返回dynamic_cast(b1)==dynamic_cast(b2); } ... int main() { DD *dd = 新的 DD(); D1 *d1 =dynamic_cast(dd); D2*d2=dynamic_cast(dd)； ... eqdc(d1, d2) ...

我想知道比较两个指向有效的空指针是否相等是否是C++中完全定义的行为（根据03或11标准），但是不同的对象。

更一般地说，但可能不那么相关，比较（==或!=）始终定义的 void* 类型的两个值，或者是它要求它们持有指向有效对象/内存区域的指针？

原文

Inspired by this answer about dynamic cast to void*:

...
bool eqdc(B* b1, B *b2) {
    return dynamic_cast<void*>(b1) == dynamic_cast<void*>(b2);
}
...
int main() {
    DD *dd = new DD();
    D1 *d1 = dynamic_cast<D1*>(dd);
    D2 *d2 = dynamic_cast<D2*>(dd);
    ... eqdc(d1, d2) ...

I am wondering if it is fully defined behaviour in C++ (according to the 03 or 11 standard) to compare two void pointers for (in)equality that point to valid, but different objects.

More generally, but possibly not as relevant, is comparing (==or !=) two values of type void* always defined, or is it required that they hold a pointer to a valid object/memory area?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

厌味 2024-12-24 12:58:03

C 说：

两个指针比较相等当且仅当两者都是空指针，并且都是指向
相同的对象（包括指向对象的指针和其开头的子对象）或函数，
两者都是指向同一数组对象最后一个元素之后的指针，或者一个是指针
一个指向一个数组对象的末尾，另一个是指向另一个数组对象的开头的指针
恰好紧随地址中第一个数组对象的数组对象
空间。

C++ 说：

如果两个相同类型的指针比较相等
并且只有当它们都为空、都指向相同的函数或者都代表相同的地址时。

因此，这意味着：

它是 C++ 中完全定义的行为（根据 03 或 11 标准），用于比较两个指向有效但不同对象的 void 指针是否相等。

所以是的，在 C 和 C++ 中都是如此。您可以比较它们，在这种情况下，当它们指向同一对象时，它们将比较为 true。这很简单。

是否比较（==或！=）始终定义的 void* 类型的两个值，或者是否要求它们保存指向有效对象/内存区域的指针？

同样，比较是明确定义的（标准说“当且仅当”，因此两个指针的每次比较都是明确定义的）。但是...

C++ 用“地址”来讨论，所以我认为这意味着标准要求它“按照我们的预期”工作，
但是，C 要求两个指针要么为空，要么指向对象或函数，或者数组对象后面的一个元素。如果我的阅读能力没有下降，这意味着如果在给定的平台上你有两个具有相同值的指针，但没有指向有效的对象（例如未对齐），则比较它们应该是明确定义的并产生错误。

这太令人惊讶了！

事实上，这不是 GCC 的工作方式：

int main() {
    void* a = (void*)1; // misaligned, can't point to a valid object
    void* b = a;
    printf((a == b) ? "equal" : "not equal");
    return 0;
}

结果：

equal

也许 C 中的 UB 拥有一个不是空指针的指针并且不指向一个对象、子对象或数组中最后一个对象之后的对象？嗯...这是我的猜测，但我们有：

整数可以转换为任何指针类型。除先前指定的情况外，
结果是实现定义的，可能未正确对齐，可能不指向
引用类型的实体，并且可能是陷阱表示。

所以我只能解释为上面的程序定义良好，C标准期望它打印“不等于”，而GCC并没有真正遵守标准，但给出了更直观的结果。

C says:

Two pointers compare equal if and only if both are null pointers, both are pointers to the
same object (including a pointer to an object and a subobject at its beginning) or function,
both are pointers to one past the last element of the same array object, or one is a pointer
to one past the end of one array object and the other is a pointer to the start of a different
array object that happens to immediately follow the ﬁrst array object in the address
space.

C++ says:

Two pointers of the same type compare equal if
and only if they are both null, both point to the same function, or both represent the same address.

Hence it would mean that:

it is fully defined behaviour in C++ (according to the 03 or 11 standard) to compare two void pointers for (in)equality that point to valid, but different objects.

So yes, in both C and C++. You can compare them and in this case they shall compare as true iff they point to the same object. That's simple.

is comparing (==or !=) two values of type void* always defined, or is it required that they hold a pointer to a valid object/memory area?

Again, the comparison is well-defined (standard says "if and only if" so every comparison of two pointers is well-defined). But then...

C++ talks in terms of "address", so I think this means that the standard requires this to work "as we'd expect",
C, however, requires both the pointers to be either null, or point to an object or function, or one element past an array object. This, if my reading skills aren't off, means that if on a given platform you have two pointers with the same value, but not pointing to a valid object (e.g. misaligned), comparing them shall be well-defined and yield false.

This is surprising!

Indeed that's not how GCC works:

int main() {
    void* a = (void*)1; // misaligned, can't point to a valid object
    void* b = a;
    printf((a == b) ? "equal" : "not equal");
    return 0;
}

result:

equal

Maybe it's UB in C to have a pointer which isn't a null pointer and doesn't point to an object, subobject or one past the last object in an array? Hm... This was my guess, but then we have that:

An integer may be converted to anypointer type. Except as previously speciﬁed, the
result is implementation-deﬁned, might not be correctly aligned, might not point to an
entity of the referenced type, and might be a trap representation.

So I can only interpret it that the above program is well-defined and the C standard expects it to print "not equal", while GCC doesn't really obey the standard but gives a more intuitive result.

回复收藏 0 原文