Printable View
Hello,
Is there an easy way to look at one bit a time of a character, and printf that number? For example, the letter a is 01100001. I would like to look at the letter a, (starting from right or left it doesnt matter) and do a printf accordingly (if its 1 then a 1 and if its a zero then a 0). Then shift one place and look at that number. So in the end when someone inputs the character 'a', I return "01100001".
Thank you.
You can use a MASK to hide all other bits except LSB and print 1or 0 depending on what the character & MASK evaluates to. You can do this for all bits in the character.
I would typically do this left to right. There are 8 bits, so you can set up a for loop to loop 8 times, starting with X'80' and shifting right each time 1 bit, ending up with X'01' as your mask. ANDing the mask with your byte will give you true or false.
Todd
Of course, you can also shift the number of times to push the bit you want to get all the way to the right and use a mask to mask out all other bits, and print the value.
Code:int n = 127;
#define B1000000 128
n &= B1000000;
n >>= 7;
printf("%i", n);
Nah... If you define some constant - you want to make its name "talking"Quote:
Originally Posted by Elysia
Code:#define QUANT_MASK (0xf) /* Quantization field mask. */
You do not use define only to say that 128 in binary is 1000000 because any programmer working with bit-shifting will use hex values like 0x40 and will be able to convert it to binary. The define is used to simplify understanding not the binary representation of the constant - but why this constant is used here.Code:#define H263P_INTRA_BIT_MASK (1<<13)
I don't know about you, but 1000 0000 looks more readable to me than 128 (or 0x80).
Especially when it comes to higher numbers.
Well, it's not necessary, though, it's up to each and everyone.
So, in your opinion, you know exactly what value 11000000000000000000000000000000 is? And it's easier to read than 0xC0000000?Quote:
Originally Posted by Elysia
Binary numbers are not easier to read, just longer [which in itself makes them HARDER in my opinion, because you loose count of the number of zeros].
You will learn to convert hex to binary and binary to hex if you work with these sort of things a lot. If you don't, it probably isn't very important which is easier - as they will both need a bit of thinking time.
--
Mats
I think this might be just about as tight as it gets.
ToddCode:#include <stdio.h>
int main (void) {
unsigned char j , c = 0xc3 ;
for (j = 0x80 ; j ; j >>= 1 ) {
printf ((c & j) ? "1" : "0" ) ;
}
return 0;
}
Or:
--Code:#include <stdio.h>
int main (void) {
unsigned char j , c = 0xc3 ;
for (j = 0x80 ; j ; j >>= 1 ) {
putchar('0' + !!(c & j)) ;
}
return 0;
}
Mats
cool!
No, of course not... That's kinda hard-ish to read.Quote:
Originally Posted by matsp
Yes, they are, but if I want to logical AND or logical OR or logical XOR with a binary string, say 0000 0010, then I might as well do a define for that, because it's easier to see what I'm actually doing the operation with rather than a decimal number. When the numbers grow too large, I used another strategy.Quote:
Binary numbers are not easier to read, just longer [which in itself makes them HARDER in my opinion, because you loose count of the number of zeros].
You will learn to convert hex to binary and binary to hex if you work with these sort of things a lot. If you don't, it probably isn't very important which is easier - as they will both need a bit of thinking time.
--
Mats
So basically, I have one to 8 bytes mask for binary. If I want to do a shift where the mask is on the second byte, I simply do num & (B0001000 << NumBytes2). It may not be the best solution, and of course, it's just a test, but in theory it seems fine.Code:const int B00000001 = 1;
const int B00000010 = 1 << 1;
const int B00000100 = 1 << 2;
const int B00001000 = 1 << 3;
const int B00010000 = 1 << 4;
const int B00100000 = 1 << 5;
const int B01000000 = 1 << 6;
const int B10000000 = 1 << 7;
const int NumBytes1 = 8;
const int NumBytes2 = 8 * 2;
const int NumBytes3 = 8 * 3;
const int NumBytes4 = 8 * 4;
const int NumBytes5 = 8 * 5;
const int NumBytes6 = 8 * 6;
const int NumBytes7 = 8 * 7;
const int NumBytes8 = 8 * 8;
Hey, thanks for the suggestions. After reading the tutorial here, and a few other threads I came up with this:
Only problem, is it gives me the numbers in inverse order. How can I change that?Code:int main(int argc, char **argv)
{
unsigned int Mask = 0x1;
int count;
int x;
x = 0;
count = 'a';
while (x < 8)
{
if (count & Mask)
printf("1");
else
printf("0");
Mask <<= 1;
x++;
}
}
You're shifting the wrong way - you should shift like Mask >>= 1 so.
With >>= it doesnt work at all.
Did you start at 0x80 instead of 1?Quote:
Originally Posted by +Azazel+
Otherwise, post the whole code!
--
Mats
Wait, no.. you're shifting the mask, not the variable. My mistake.Quote:
Originally Posted by +Azazel+
It's wrong because you're starting from the wrong side of the number. Start from the high order:
Main can just be main(void) since you aren't using any of the command lines. You must include stdio.h and for the sake of gods, use a for loop instead - it looks better.Code:int main()
{
unsigned int Mask = 0x80;
int count;
int x;
x = 0;
count = 'a';
for (x = 0; x < 8; x++)
{
if (count & Mask)
printf("1");
else
printf("0");
Mask >>= 1;
}
}
That works, Thank you!
What if I also want to assign values to the bits, not just extract them. What would be the method to do that?
What do you mean by "assign values to the bits"? You mean print 0, 64, 32, 0, 0, 0, 0, 1 or some such?Quote:
Originally Posted by +Azazel+
--
Mats
I believe it means that the OP wants to assign bits to a binary number, such as 0000 0000 becomes 0001 0000.
In that case, you simply binary OR the appropriate mask. Like 0x80 sets the highest bit (eg 1000 0000).
Yes indeed, that is what I meant. Thank you very much!Quote:
I believe it means that the OP wants to assign bits to a binary number, such as 0000 0000 becomes 0001 0000.
In that case, you simply binary OR the appropriate mask. Like 0x80 sets the highest bit (eg 1000 0000).