> first : in this example bit size is a BYTE ?!
no, bit size is always a bit. but you defined:
struct nibble
{
unsigned a:1;
...
};
in this case _unsigned_ evaluates on most platforms nowadays (since they are
32-bit architectures) to _unsigned_ _int_ (i.e. to 32 bit, or _four_ byte)!
you have to declare your struct like this:
struct nibble
{
unsigned char a:1;
unsigned char b:1;
unsigned char c:1;
unsigned char d:1;
};
since, the compiler always have to put your struct in at least one byte, you
also want to declare which bits you want of this byte.
so the better way is (a..highest bit, d..lowest bit):
rem.: bits a used from lowest first to highest!
struct highnibble
{
unsigned char unused:4;
unsigned char d:1;
unsigned char c:1;
unsigned char b:1;
unsigned char a:1;
};
struct lownibble
{
unsigned char d:1;
unsigned char c:1;
unsigned char b:1;
unsigned char a:1;
unsigned char unused:4;
};
union ubyte
{
struct highnibble a;
struct lownibble b;
char c;
}
than
printf ("\n %u " , sizeof (struct highnibble) ) ;
printf ("\n %u " , sizeof (srtuct lownibble) ) ;
printf ("\n %u " , sizeof ( char ) ) ;
should all evalute to one!
in your last use of ubyte
union ubyte ub.c = 'a' ;
printf ("\n\n %c " , ub.c ) ;
printf ("\n %u " , ub.a.high ) ;
printf ("\n %u " , ub.a.low ) ;
you have made the mistake, that the nibble will always access the structure
- or in your case a 32-bit integer - and not simply four bits. if you want
to print out a nibble you have to either use a bit-mask, or use c++ and
operator overload.
but if you take your structure as used, you will never only access a nibble
(part) of your byte!
example (c-code):
#include <stdio.h>
#define ACCESS_NIBBLE_LOW(_x) ((_x)&0x0f)
#define ACCESS_NIBBLE_HIGH(_x) (((_x)&0xf0)>>4)
int main(void)
{
const unsigned char N_HIGH=0xf0, N_LOW=0x0f;
typedef struct
{
unsigned char x:4; /* bits 0..3 */
unsigned char d:1; /* bit 4 .. 2^4=16 */
unsigned char c:1; /* bit 5 .. 2^5=32 */
unsigned char b:1; /* bit 6 .. 2^6=64 */
unsigned char a:1; /* bit 8 .. 2^7=128*/
} nibblehigh;
typedef struct
{
unsigned char d:1; /* bit 0 .. 2^0=1 */
unsigned char c:1; /* bit 1 .. 2^1=2 */
unsigned char b:1; /* bit 2 .. 2^2=4 */
unsigned char a:1; /* bit 3 .. 2^3=16*/
unsigned char y:4; /* bits 4..7 */
} nibblelow;
typedef union
{
nibblehigh high;
nibblelow low;
char c;
} ubyte;
printf("\n %u", sizeof(nibblehigh));
printf("\n %u", sizeof(nibblelow));
printf("\n %u", sizeof(ubyte));
printf("\n %u", sizeof(char));
ubyte ub;
ub.c = 65+32; /* 'a' */
printf("\n\n %u %c %c", ub.c, ub.high, ub.low);
printf("\n %u %u", ACCESS_NIBBLE_HIGH(ub.c), ACCESS_NIBBLE_LOW(ub.c));
ub.high.c = 0; /* make uppercase (remove bit 5 : 32=2^5) */
printf("\n\n %u %c %c", ub.c, ub.high, ub.low);
printf("\n %u %u", ACCESS_NIBBLE_HIGH(ub.c), ACCESS_NIBBLE_LOW(ub.c));
return 0;
}
hope it will help
godfired
