Problem in bitwise

[lolguy]

i rlly dunt understand how to turn bit off but as book says to turn bit on you do
#define MARRIED (1<<3) //whish is = 8
and status =status | married; <<how the hell it turn bit on
lets say status == 5
and 8(00001000)
5(00000101)
you do or it will just change
to this (00001101);
how it suppose to turn it on ??
i understand that turn off bit
status |=~MARRIED; i understand that
and if(Status & married);

can please also someone show the uses of flags coz this chapter is rlly anoying thanks alot guys

[Meldreth]

bitwise or says that bit n will be set if bit n in either of the operands is set. take 5 and 8.

00001000
00000101 |
--------
00001101

oring them together gives you 00001101 because those three bits were set in either 5 or 8. turning a bit off works the same way. bitwise and says that bit n will be set if bit n in both of the operands is set. take 5 and 4

00000100
00000101 &
--------
00000100

the first bit is turned off because there's only one set and not two. but what you wanted to do is turn off the third bit. so you invert 4 to make it a mask. when you make a mask it means that all but the bit you want is set. that way when the and happens, the bit you want gets unset.

11111011
00000101 &
--------
00000001

That's why setting a bit uses or and unsetting a bit uses inversion and and.

#define BIT(i) (1<<i)
#define SET(x,i) ((x) | BIT(i))
#define UNSET(x,i) ((x) & ~BIT(i))

[lolguy]

oh thanks i get it now

[brewbuck]

To set a bit:

val |= BIT;

To unset a bit:

val &= ~BIT;

[MK27]

I'm a bit late with this (it took some time) but I think it demonstrates all of the bit operations in an easy to understand way:

#include <string.h>
#include <stdio.h>

typedef struct {
	unsigned char b7:1;
	unsigned char b6:1;
	unsigned char b5:1;
	unsigned char b4:1;
	unsigned char b3:1;
	unsigned char b2:1;
	unsigned char b1:1;
	unsigned char b0:1;
} _byte;

union byte {
	unsigned char X;
	_byte B;
};

char string[9];

char *byte2str (union byte A) {
	sprintf(string, "%d-%d-%d-%d-%d-%d-%d-%d",A.B.b0,A.B.b1,A.B.b2,A.B.b3,A.B.b4,A.B.b5,A.B.b6,A.B.b7);
	return string;
}

int main(int argc, char *argv[]) {
	union byte input, up, down;
	unsigned char I=atoi(argv[1]);
	
	input.X=I;
        up.X=I<<atoi(argv[2]); 
	down.X=I>>atoi(argv[2]);
	
	printf("input=%d \t%s\n",input,byte2str(input));
	input.X=~input.X;
	printf("  not=%d \t%s\n",input,byte2str(input));
	input.X=I; input.X&=up.X;
	printf("\n    up=%d \t%s\n",up,byte2str(up));
	printf("and up=%d \t%s\n",input,byte2str(input));
	input.X=I; input.X|=down.X;
	printf("\n   down=%d \t%s\n",down,byte2str(down));
	printf("or down=%d \t%s\n",input,byte2str(input));
	return 0;
}

You give it two numbers, the first is "input" and the second the size of a shift:

./a.out 5 2
input=5 	0-0-0-0-0-1-0-1
  not=250 	1-1-1-1-1-0-1-0

    up=20 	0-0-0-1-0-1-0-0
and up=4 	0-0-0-0-0-1-0-0

   down=1 	0-0-0-0-0-0-0-1
or down=5 	0-0-0-0-0-1-0-1

"or down" is the same as input since input already has the least significant bit set.

./a.out 57 3
input=57 	0-0-1-1-1-0-0-1
  not=198 	1-1-0-0-0-1-1-0

    up=200 	1-1-0-0-1-0-0-0
and up=8 	0-0-0-0-1-0-0-0

   down=7 	0-0-0-0-0-1-1-1
or down=63 	0-0-1-1-1-1-1-1

ps. this is nifty if you change I and X to signed but then you have to "legalize" some stuff in the printf statements.

[lolguy]

yah thanks alot i understand it now i also did this code for flags

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#define MALE (1<<0)
struct employee
{
       int flags;
};typedef struct employee emp;
void read_in(emp * e)
{
  char answer;
  e->flags=0;
  fputs("Female or male (F/M) ? ",stdout);
  answer=getchar();
  if(toupper(answer)=='M')
          e->flags|=MALE;
  else
          e->flags&=~MALE;
}
void print_emp(emp * e)
{
     puts( (e->flags &&  MALE )? "MALE" : "FEMALE");
     getchar();
}
int main(void)
{
    emp e;
    read_in(&e);
    print_emp(&e);
    return getchar();
}

[MK27]

A little clearer and simpler:

#define MALE 1
puts( (e->flags)? "MALE" : "FEMALE");

There is no point to (e->flags && MALE) -- perhaps you meant (e->flags==MALE).
I wanted to point that out because you are not really using a bit flag here (whether it's == or &&), you are just testing whether e->flags is 0 (false) or more than 0 (true) which it would be if you bit shifted it.

Or perhaps you really meant &=

[lolguy]

A little clearer and simpler:

#define MALE 1
puts( (e->flags)? "MALE" : "FEMALE");

There is no point to (e->flags && MALE) -- perhaps you meant (e->flags==MALE).
I wanted to point that out because you are not really using a bit flag here (whether it's == or &&), you are just testing whether e->flags is 0 (false) or more than 0 (true) which it would be if you bit shifted it.

Or perhaps you really meant &=

no that chk if its turned on or off if there on then its male if its off then its female

[tabstop]

A little clearer and simpler:

#define MALE 1
puts( (e->flags)? "MALE" : "FEMALE");

There is no point to (e->flags && MALE) -- perhaps you meant (e->flags==MALE).
I wanted to point that out because you are not really using a bit flag here (whether it's == or &&), you are just testing whether e->flags is 0 (false) or more than 0 (true) which it would be if you bit shifted it.

Or perhaps you really meant &=

I think the assumption is that there will, eventually, be other flags than just MALE -- and so checking which flag is actually set is then important. (Edit: Granted it should be &.)

[MK27]

no that chk if its turned on or off if there on then its male if its off then its female

I think the short story is that you have tricked yourself into believing your theory is correct because you got a correct answer. BUT, if e->flags were 4, (in which case the first bit is not set), your function would still return true because 4 is greater than zero.
So using e->flags in this way, you cannot usefully add, for example:

#define EMPLOYED 2<<0

Because your function is not checking the bits of e->flags, it's just checking to see if it's more than zero. && MALE is meaningless because it now means if ((e->flags>0) && (MALE>0)). Of course male is greater than zero.

You could use:

puts( (e->flags &&  sky==blue)? "MALE" : "FEMALE");

But what's the point?

[lolguy]

e->flags is a int not a bit u cant compare it u must first to change it to bits by comparing if turned on before
[code]
if(toupper(answer)=='M')
e->flags|=MALE;
else
e->flags&=~MALE;
here check if its on or off if he puts M or m it bit will be on

else it will be off also for your code the = has higher precedence than the & so it wont work.

[panmingen]

Hi brewbuck,

May i ask for the code,

val |= BIT;

how does the "|=" operator work?

I understand how they work individually, but don't understand how they are used together.

Cheers

[MK27]

lolguy: I am just warning you, if it matters YOU ARE WRONG. I in no way implied that e->flags was anything but an int. You need to believe me, do a couple of experiments, and think harder.

panmingen google "bitshift C tutorial" and "bitwise operations C tutorial", read whatever you want, then look at post #5.

[matsp]

Just to clarify this snippet:

#define EMPLOYED 2<<0

Generally, we'd use 1 << X, where X is the bit number, e.g:

#define EMPLOYED 1 << 0
#define MARRIED    1 << 1
#define MALE          1 << 2

Another helpful trick is to use enum instead of #define:

enum FlagBits
{
     Employed = 1 << 0,
     Married = 1 << 1,
     Male = 1 << 2
};

That way, a debugger MAY be able to show you at least the value of individual bits, even if it can't figure out that (6) means (Married | Male).

--
Mats

[MK27]

Generally, we'd use 1 << X, where X is the bit number,

Good idea