Please don't use the words "left" and "right" when talking about endianness. If left and right mattered, I could alter the endianness of my machine by turning it upside down. What matters is whether the least significant component of the value is stored at the lowest memory address (little endian) or the highest memory address (big endian). Since bits are not addressable, the question of bit-wise endianness has no meaning.
Code://try //{ if (a) do { f( b); } while(1); else do { f(!b); } while(1); //}
:eyebrow:Originally Posted by brewbuck
So if I tip my computer over on its side, did I just change what was low and what was high?
Quzah.
Hope is the first step on the road to disappointment.
Naaa... but you probably just dumped all the dust inside out onto your carpet...So if I tip my computer over on its side, did I just change what was low and what was high?
Quzah.
Damn. You got me.:eyebrow:So if I tip my computer over on its side, did I just change what was low and what was high?
Quzah.
Code://try //{ if (a) do { f( b); } while(1); else do { f(!b); } while(1); //}
Yep! especially when interfacing a big-endian micro with a little-endian peripheral like the RS232 serial interface.
There are plenty of microcontrollers 'n microprocessors that are little endian and in 'em a byte will be stored with the LSB at the lowest memory slot.
Yep! for that one would have to drop down to the assembly level.
For starters, the OP wanted to know how data is laid out in memory, not how it's interpreted or displayed.
That being the case a byte in memory will be stored as per the endianness of the microarchitecture.
Though its interpretation will always from the MSB to LSB, regardless of the micros endianness.
Last edited by itCbitC; 09-02-2011 at 11:03 AM.
Would this work, or would the struct members switch places depending on endianness?
I'm a bit unsure of which is which, so I might have gotten big and little endian mixed upCode:#include <stdio.h> union endiantest { struct { unsigned char low : 1; unsigned char pad : 6; unsigned char high: 1; }; unsigned char val; }; int main() { union endiantest test = {0}; if(sizeof(test) != 1) { printf("Sorry, your compiler doesn't support byte-sized bitfields\n"); return 1; } test.val = 1; if(test.low) printf("Little endian\n"); else if(test.high) printf("Big endian\n"); else printf("Weird endian\n"); return 0; }
Unless individual bits can be ADDRESSED (not just accessed), the question has no meaning. Sure, I can access the MSB of a byte by AND'ing with 0x80, this still tells me nothing about how the bits are arranged in physical memory, nor is that even relevant. If the architecture allowed actual indexing of bits, such that ram[i] returned the i'th bit in RAM, then the architecture would have a bit-endianness. Otherwise, it does not. It's not that you can't measure it, it's that it's meaningless. Endianness is the relationship between significance and addressing. If there is no addressing there is no relationship.
Code://try //{ if (a) do { f( b); } while(1); else do { f(!b); } while(1); //}
Yeah, we're in agreement on one or two things. I don't think I was as clear as I could have been. I was making two points:
1. Byte-endianness of an architecture is irrelevant for single-byte variables like char.
2. Bit-endianness is impossible to determine in C, so discussion of it is frivolous.
can't i use something like below
see the result belowCode:#include <stdio.h> int main() { unsigned char ch[3] = "AB"; //0x410x42 unsigned char *pch= ch; printf (" *pch or ch[0]= %x and *(pch+1) or ch[1]=%x\n ", *pch,*(pch+1)); c= ch[0]; printf("ch[0] bitwise is : \n"); printf("ch[0](i) bitval\n"); for (i=0 ; i<sizeof(char)*8; i++) { printf("%d %x \n ",i,(c >> i)&0x01); } }
now,0x41 or 65 would be 01000001 , but the output above is 10000010.
now, 1 is the LSB, and if it was stored at higher memory address, its value
acessed using a char pointer would not be 65d but 130d. so, this shows that
bits are little endian.
You are getting 10000010 because you are printing your byte in reverse. Put another way: you can't say that 0x01 has the "last" bit on, because if the byte is stored the other way then you get the first bit on instead. The operations you are doing will give you exactly the same answer regardless of whether the bits are stored low-bit-first, low-bit-last, or low-bit-in-the-middle-spiraling-outward.
That's not bit-endianness. Consider this:That still doesn't tell us anything, because foo & 1 is always going to result in 1 if the first bit is set, regardless on which end of the byte the bit is.Code:#include<stdio.h> int main( void ) { union u { struct byte { unsigned int b0:1; unsigned int b1:1; unsigned int b2:1; unsigned int b3:1; unsigned int b4:1; unsigned int b5:1; unsigned int b6:1; unsigned int b7:1; } bm; unsigned char uc; } b; b.uc = 0xF0; printf( "%d%d%d%d %d%d%d%d\n", b.bm.b0, b.bm.b1, b.bm.b2, b.bm.b3, b.bm.b4, b.bm.b5, b.bm.b6, b.bm.b7 ); return 0; }
Quzah.
Hope is the first step on the road to disappointment.
No. You've heard several times, from several people, that bit-endianness can not be determined in C. You cannot address bits, there is no way to check endianness. End of story.
And as others pointed out, printing something backwards doesn't prove it's stored backwards, it just proves you can print it backwards.now,0x41 or 65 would be 01000001 , but the output above is 10000010.
now, 1 is the LSB, and if it was stored at higher memory address, its value
acessed using a char pointer would not be 65d but 130d. so, this shows that
bits are little endian.
ok,
all right.
thanks
