Thread: Using bitshifting to convert to binary.

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);

Originally Posted by Elysia

#define B1000000 128

Nah... If you define some constant - you want to make its name "talking"

Code:

#define	QUANT_MASK	(0xf)		/* Quantization field mask. */

Code:

#define H263P_INTRA_BIT_MASK         (1<<13)

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.

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.

Originally Posted by Elysia

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?

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

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

Originally Posted by matsp

So, in your opinion, you know exactly what value 11000000000000000000000000000000 is? And it's easier to read than 0xC0000000?

No, of course not... That's kinda hard-ish to read.

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

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.

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;

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.

You're shifting the wrong way - you should shift like Mask >>= 1 so.

Originally Posted by +Azazel+

With >>= it doesnt work at all.

Did you start at 0x80 instead of 1?

Otherwise, post the whole code!

--
Mats