Which definition is that?

You probably though of:

  array  == &array[0]

which is always true.

This:

  (void*)&array   == (void*)&array[0]

which simplifies to:

    (void*)&array   == (void*)array

is not.

C doesn't guarantee that the values of &array and array are the same. The types T( * )[ * ] and T* are not even compatible and those two pointers are allowed to have different sizes and representation.

The first element of an array is located at the address of an array. Even if the pointer-to-array and pointer-to-element types have different size and representation, they point to the same place. The resulting pointer-to-void converted values must point to that place, and have the same type.

This relationship is also true between a pointer to a struct and a pointer to the first element. And also among pointers to the elements of a union.

Granted, we've been presupposing C, but:

In C++ you have a simple out by overloading T::operator&, allowing you to alter the result of the RHS of that equation and break it.

There's also a little bit in the standard prohibiting comparing pointers to different arrays - a leftover from the 16-bit era of near and far pointers I suspect - but that appears to only apply to relational comparisons in the C++11 standard:

http://stackoverflow.com/questions/9086372/how-to-compare-po...

I either misremember this applying to == and != as well (likely), or this changed since the C++03 standard that I'm used to referencing (unlikely). I'm also unsure if C has an equivalent rule. A fun note from that SO link:

    std::less<T*>

guarantees more than

    operator<( T*, T* )

enabling

    std::map<T*,...>

et all.

(edit: formatting)