I'm using Visual Studio.NET specifically the C++ compiler, and I'm writing a mini-compiler of my own. I read in 16 bit numbers, and I need to break them down (isolate certain groups of bits).

I wrote a Get_Bits function (just now) that I will paste below. My problem is that when I do a left shift, instead of deleting the bits shifted out of the 16 bit scope, the integer simply gets extended. I need those bits to be deleted so I can extract certain sections, such as bit 6-8 or something like that.

int _tmain(int argc, _TCHAR* argv[])
{
unsigned int temp;
temp = 0x1FF3;
cout<<hex<<temp<<endl;
temp=Get_Bits(temp,5,5);
cout<<temp<<endl;
return 0;
}
unsigned int Get_Bits(unsigned int instruction, int lower, int upper)
{
int left, right;
for (left=0;left<(15-upper);left++)
{
instruction=instruction<<1;
cout<<"<<"<<instruction<<endl;
}
for (right=0;right<(lower+left);right++)
{
instruction=instruction>>1;
cout<<">>"<<instruction<<endl;
}
return instruction;
}

With the value I have assigned to temp in my main, and the parameters entered into the call to Get_Bits, I would like to clear everything but the fifth bit from the right (start counting with zero). Instead this is my resulting output.

I need some way to cap the unsigned int at 16 bits, so that the shifting will indeed just clear bits. Or if you have suggestions as to how I can do this more easily, I would appreciate those as well.

You don't need to shift to 'clear' some undesired bits, just use and operator.
I will describe you pseudo code:

1) Construct a mask. By example if you want bits 4 to 9, your mask will be 000000000000001111110000
2) Apply the mask to the original number by example to: 00001111000011110000111100001111
Result will be (I hope): 00000000000000000000001100000000
3) Now shift to the right using the lower value (4 in this example)
Result will be (I hope again): 00000000000000000000000000110000
4) Your desired bits are now in first 6 bits.

To build your mask (1):
int mask = (1<<(high-low+1))-1)<<low;

To apply the mask and shift (2) and (3):
int desiredBits = (myNumber & mask)>>low;

So, if you join all:
int desiredBits = (myNumber & ((1<<(high-low+1))-1)<<low))>>low;

I guess it can be reduce to:
int desiredBits = (myNumber>>low) & (1<<(high-low+1))-1);

0

Question has a verified solution.

Are you are experiencing a similar issue? Get a personalized answer when you ask a related question.

I will describe you pseudo code:

1) Construct a mask. By example if you want bits 4 to 9, your mask will be 000000000000001111110000

2) Apply the mask to the original number by example to: 00001111000011110000111100

Result will be (I hope): 00000000000000000000001100

3) Now shift to the right using the lower value (4 in this example)

Result will be (I hope again): 00000000000000000000000000

4) Your desired bits are now in first 6 bits.

To build your mask (1):

int mask = (1<<(high-low+1))-1)<<low;

To apply the mask and shift (2) and (3):

int desiredBits = (myNumber & mask)>>low;

So, if you join all:

int desiredBits = (myNumber & ((1<<(high-low+1))-1)<<low

I guess it can be reduce to:

int desiredBits = (myNumber>>low) & (1<<(high-low+1))-1);