In article <11**********************@z14g2000cwz.googlegroups .com>,
Old Wolf <ol*****@inspire.net.nz> wrote:
:Walter Roberson wrote:
:> Richard Bos wrote:
:> Old Wolf wrote:
:> >Not true. For example, pointers to different members of a
:> >union must compare equal.
:> Only when "suitably converted".
:I presumed that Richard's comment was before "suitable
:conversion" in situations where no explicit conversion
:is required.
:Otherwise I don't see the value of what he is saying,
:since it isn't possible to compare two non-null pointers
:of different type (if you try to do so, and no constraint
:violations occur, one of them will undergo an implicit conversion).
His point was that there are constrain violations involved in all
such cases of comparing non-NULL pointers of different types.
And he was right except that he missed the void* case (which I
probably would have missed too.)
:Can you post some sample code,
:if my above paragraph is unclear?
Your wording implied that for any two union members, &u.i == &u.j
and my reply was that "You can't do that" unless the types are
compatable or you have undertaken a cast that might have no meaning.
In the code below, gcc and SGI's cc warn about every pointer comparison
except when comparing identical objects or when comparing void * to
another pointer.
I was thinking of chopping out the identical object case when I
generated the table; the result turned out to be interesting.
In SGI's cc, u.Float == u.Float and u.Double == u.Double but in
gcc, u.Float != u.Float and u.Double != u.Double . (These are
not pointer comparisons, they are comparisons of the result of
interpreting a pointer as float or double.) This might be chance
positioning on the stack, but I suspect more likely it is NaN checks,
since IEEE 754 defines NaN to not compare equal to itself.
#include <stdio.h>
#define CP(T1,T2) printf( "&u.%s %s &u.%s\n", #T1, \
&u.T1 == &u.T2 ? "==" : "!=", #T2 )
#define CP2(T1,T2) printf( "u.%s %s u.%s\n", #T1, \
u.T1 == u.T2 ? "==" : "!=", #T2 )
#define CP3(T1,T2) printf( "u.%s %s &u.%s\n", #T1, \
u.T1 == &u.T2 ? "==" : "!=", #T2 )
int main(void) {
union {
float Float;
double Double;
int Int;
long Long;
short Short;
char Char;
long long LongLong;
unsigned int UnsignedInt;
unsigned char UnsignedChar;
void* VoidPtr;
} u;
u.VoidPtr = (void *)&u;
CP(Float,Float);
CP(Double,Float);
CP(Double,Double);
CP(Int,Float);
CP(Int,Double);
CP(Int,Int);
CP(Long,Float);
CP(Long,Double);
CP(Long,Int);
CP(Long,Long);
CP(Short,Float);
CP(Short,Double);
CP(Short,Int);
CP(Short,Long);
CP(Short,Short);
CP(Char,Float);
CP(Char,Double);
CP(Char,Int);
CP(Char,Long);
CP(Char,Short);
CP(Char,Char);
CP(LongLong,Float);
CP(LongLong,Double);
CP(LongLong,Int);
CP(LongLong,Long);
CP(LongLong,Short);
CP(LongLong,Char);
CP(LongLong,LongLong);
CP(UnsignedInt,Float);
CP(UnsignedInt,Double);
CP(UnsignedInt,Int);
CP(UnsignedInt,Long);
CP(UnsignedInt,Short);
CP(UnsignedInt,Char);
CP(UnsignedInt,LongLong);
CP(UnsignedInt,UnsignedInt);
CP(UnsignedChar,Float);
CP(UnsignedChar,Double);
CP(UnsignedChar,Int);
CP(UnsignedChar,Long);
CP(UnsignedChar,Short);
CP(UnsignedChar,Char);
CP(UnsignedChar,LongLong);
CP(UnsignedChar,UnsignedInt);
CP(UnsignedChar,UnsignedChar);
CP(VoidPtr,Float);
CP(VoidPtr,Double);
CP(VoidPtr,Int);
CP(VoidPtr,Long);
CP(VoidPtr,Short);
CP(VoidPtr,Char);
CP(VoidPtr,LongLong);
CP(VoidPtr,UnsignedInt);
CP(VoidPtr,UnsignedChar);
CP(VoidPtr,VoidPtr);
CP2(Float,Float);
CP2(Double,Float);
CP2(Double,Double);
CP2(Int,Float);
CP2(Int,Double);
CP2(Int,Int);
CP2(Long,Float);
CP2(Long,Double);
CP2(Long,Int);
CP2(Long,Long);
CP2(Short,Float);
CP2(Short,Double);
CP2(Short,Int);
CP2(Short,Long);
CP2(Short,Short);
CP2(Char,Float);
CP2(Char,Double);
CP2(Char,Int);
CP2(Char,Long);
CP2(Char,Short);
CP2(Char,Char);
CP2(LongLong,Float);
CP2(LongLong,Double);
CP2(LongLong,Int);
CP2(LongLong,Long);
CP2(LongLong,Short);
CP2(LongLong,Char);
CP2(LongLong,LongLong);
CP2(UnsignedInt,Float);
CP2(UnsignedInt,Double);
CP2(UnsignedInt,Int);
CP2(UnsignedInt,Long);
CP2(UnsignedInt,Short);
CP2(UnsignedInt,Char);
CP2(UnsignedInt,LongLong);
CP2(UnsignedInt,UnsignedInt);
CP2(UnsignedChar,Float);
CP2(UnsignedChar,Double);
CP2(UnsignedChar,Int);
CP2(UnsignedChar,Long);
CP2(UnsignedChar,Short);
CP2(UnsignedChar,Char);
CP2(UnsignedChar,LongLong);
CP2(UnsignedChar,UnsignedInt);
CP2(UnsignedChar,UnsignedChar);
/*
Void* to a non-pointer won't pass the parser so skip that
and try pointer tests instead
*/
CP3(VoidPtr,Float);
CP3(VoidPtr,Double);
CP3(VoidPtr,Int);
CP3(VoidPtr,Long);
CP3(VoidPtr,Short);
CP3(VoidPtr,Char);
CP3(VoidPtr,LongLong);
CP3(VoidPtr,UnsignedInt);
CP3(VoidPtr,UnsignedChar);
CP3(VoidPtr,VoidPtr);
}
--
"[...] it's all part of one's right to be publicly stupid." -- Dave Smey
