了解C编程中的位操作（设置/清除）

Question

I'm stuck understanding bit operations on integers in C.

Suppose I have the number 13. Its binary representation is 1101 . How can I set the bit at its second position? How can I clear the bit?

Here is the function I wrote so far for setting the bit:

int setBit(int data, int pos, int val)
{       
    if (val==1)
        data |= (1U << (pos - 1));
    else
        data ^= (1U << (pos-1));

    return data;
}

Will this work correctly?

Answer 1

n = n & (~(1U <<x)) will reset the bit in position x. Actually what we are doing suppose n=1101 We want to reset 3rd bit.

How does it work?

So 1U <<3=000....1000

~( 1U <<3)=111....0111

n=000..1101

& 111..0111

Result is 000..0101.

For inserting a bit y at position x:(position starts from 0)

1101---->11y01 Giving the example for position 2.

num= FFFF FFFF (in hex)(all 1's) //1111......1111
number=N  // in which you will insert bit
num1=num<<x;      //for x=2 as in this case
                  //num1=1111.....1100
num2=~(num1);     //num2=0000.....0011
lowbits=N & num2; //    =0000.....0001 (N=1101)
highbits= N &num1;//    =0000.....1100
highbits<<=1;     //    =0000....11000 
N= highbits | lowbits;//=0000....11001

Now set the x-th bit(here x=2) as you required using the method described below

---

Note : More generally changing the kth bit of number n to y (maybe 0 or 1) can be done this way

n^=(-y ^ n) & (1U <<k); (&- logical and)

Deletion of a bit is similar to insertion. Step by step perform the operation and you will get it.

EDIT : I have changed the use of 1 to 1U because in first case when using only 1 without any modifiers is defined to be an signed int. From K&R the right shifts of signed values are implementation defined. Also if you left-shift a signed number so that the sign bit is affected, the result is undefined.

These operations on unsigned value have well define behaviour: Vacated fields are filled with zeroes.

Answer 2

Setting, clearing and toggling the state of a bit is straightforward:

inline void bit_set (unsigned long *bf, unsigned char n) 
{ *bf |= (1 << n); }

inline void bit_clear (unsigned long *bf, unsigned char n) 
{ *bf &= ~(1 << n); }

inline void bit_toggle (unsigned long *bf, unsigned char n) 
{ *bf ^= (1 << n); }

Note: bitfields, and the functions above, are zero based (ie the least significant bit is bit 0 not bit 1 ) So if you want to clear, set or toggle the second bit from the right ( bit index 1 , the 2's bit (binary) , or bit 2 counting right-to-left), you pass a bit index of 1 . n in the functions above is the bit index . The following is a quick reference:

           +-----+-----+-----+-----+-----+-----+-----+-----+
bit index  |  7  |  6  |  5  |  4  |  3  |  2  |  1  |  0  |
           +-----+-----+-----+-----+-----+-----+-----+-----+
binary     | 128 |  64 |  32 |  16 |   8 |   4 |   2 |   1 |
           +-----+-----+-----+-----+-----+-----+-----+-----+

Here is a quick example of the use operating on bit 1 , (the 2's bit in binary):

#include <stdio.h>
#include <stdlib.h>

#define WDSZ 64

/* bit functions */
inline void bit_set     (unsigned long *bf, unsigned char n) { *bf |= (1 << n); }
inline void bit_clear   (unsigned long *bf, unsigned char n) { *bf &= ~(1 << n); }
inline void bit_toggle  (unsigned long *bf, unsigned char n) { *bf ^= (1 << n); }

/* simple return of binary string */
char *binstr (unsigned long n);

int main (int argc, char **argv) {

    unsigned long bf = (argc > 1) ? strtoul (argv[1], NULL, 10) : 13;

    printf ("\n original value  : %3lu  (%s)\n", bf, binstr (bf));

    bit_set (&bf, 1);
    printf (" set bit 1       : %3lu  (%s)\n", bf, binstr (bf));

    bit_clear (&bf, 1);
    printf (" clear bit 1     : %3lu  (%s)\n", bf, binstr (bf));

    bit_toggle (&bf, 1);
    printf (" toggle bit 1    : %3lu  (%s)\n\n", bf, binstr (bf));

    return 0;
}

/* simple return of binary string */
char *binstr (unsigned long n) {

    static char s[WDSZ + 1] = {0};
    char *p = s + WDSZ;

    while (n) {
        p--;
        *p = (n & 1) ? '1' : '0';
        n >>= 1;
    }
    return p;
}

Output

$ ./bin/bitsetcleartoggle

 original value  :  13  (1101)
 set bit 1       :  15  (1111)
 clear bit 1     :  13  (1101)
 toggle bit 1    :  15  (1111)

Answer 3

Here is a simple answer for what I understand your problem to be:

int setBit(int data, int pos, int val) {
    if (val)
        return data | (1U << (pos - 1));
    else
        return data & ~(1U << (pos - 1));
}

But I think numbering the bits starting at 1 is not a good idea. The more common usage is to number the bits from 0 to sizeof(type) * CHAR_BIT - 1

Answer 4

whenever I have a problem like this I will break it down into smaller parts...

suppose i have no 13 binary of 13 is 1101

now how can i add extra bit at second position?

ok that is pretty straight forward... first let make a number with a bit in the second position, zero's everywhere else... we will use an int for convenience...

int mask = 2; // or 0x2 if you rather or 0b10 if your compiler supports that ...

well that isn't very special, I can't reuse that machinery as it were... so let try a different way...

int mask = 1 << 1; // 1 in the fist position moved one to the left...

ok now we have part, now there are 2 intuitive ways to set that on our 13...

int answer = 13 | mask; // binary OR

or

int answer = 13 + mask;

these 2 are the same for 13... but will give you different answers for 14... because + always adds the value, and | will only change the bits that aren't set on the left side... so you need to pick the semantics that are correct for you...

now your second question is a little trickier ... first we will pick the same mask...

//pick nth bit
int mask = 1 < n;
// now to toggle that on a number... XOR
int answer = q ^ mask;

I like using the n'th vs position because it makes more sense in the 0 case...

Answer 5

    //For Inserting Bit 

    int insertbit(int data,int pos,int val)
{
    int no1,no2;

    no1=data;

    no1=no1>>(pos-1);

    no1=no1<<(pos-1);

    no2=data-no1;

    no1=no1<<1;

    no1=no1 | no2;

        if(val==1)
      {
           no1=setbit(no1,pos,val);
      }

    return no1;
}

          //Setting Bits



    int setbit(int data,int pos,int val)
{
            int no=1;

           no=no<<(pos-1);

            if(val==0)
        {
            no=~no;
            data=data&no;
        }   
            else
        {
            data=no|data;
        }


        return data;

}

I Coded This Way But I Need Some Shortcut for code insert function