Reversing bits and converting binary to decimal in C - c

Question

I'm building a function that, given an integer, reverses all 32 of its bits (including sign bit), converts that into a new integer, and returns it. I've almost finished it but I've run into two problems:
Part 1:
If I give it test(15); then
buffer = 11110000000000000000000000000000, which is indeed 15 with all the bits reversed.
but if I give it test(-15); then
buffer = 10001111111111111111111111111111, which is NOT right, it should be 10001000000000000000000000000001 (the 1 at the end is the sign bit). So for negative values, building my buffer string is going awry. Should I just change it to a positive integer, reverse the bits, and change the bit at the end to 1? Or is there some easier way of building this string?
Part 2:
"answer", the integer I'm returning that is supposed to represent these numbers, is never accurate. If I give it test(1500) answer = 185, when it should be 1000341504. What's the best way to turn a 32-bit binary number into an integer?
my code:
int test(int var){
printf("reversing %d:\n", var);
char buffer[32];
int i = 0;
int power = sizeof(var) * 8;
int answer = 0;
while(power > 0){
//check the lowest bit and put a 0 or 1 into the array
if((var & 1) == 1){
buffer[i] = '1';
i++;
}
else{
buffer[i] = '0';
i++;
}
//shift to the next bit
var>>= 1;
power--;
}
i++;
buffer[i] = '\0';
printf("\nbuffer = %s", buffer);
//loop through the array in reverse, building the number
while(i > 0){
if(buffer[i] == '0'){
i--;
}
else{
answer += (2 ^ (32 - i)); //here is where I try to add up answer
i--;
}
}
printf("\nanswer = %d \n\n\n\n", answer);
return 0;
}

Answer 1

The incorrect part of your conversion is:
answer += (2 ^ (32 - i))
2 ^ (32 - i)) is 2 XOR (32 - i), because ^ is the XOR-operator.
I'd do the conversion like this:
unsigned int answer = 0, pow=1;
for(int i = sizeof(buffer) - 1; i >= 0; --i)
{
int bit = buffer[i] - '0';
answer += bit * pow;
pow *= 2;
}
By doing it backwards (from 31 to 0), you don't have to use pow or create a
function that does 2 to the power of i. That would give you the integer value
of your binary interpretation, always positive. If you want to the integer value
of a 2-complement binary:
int answer = 0;
unsigned int pow=1;
for(int i = sizeof(buffer) - 1; i > 0; --i)
{
int bit = buffer[i] - '0';
answer += bit * pow;
pow *= 2;
}
if(buffer[0] == '1')
answer |= 0x80000000; // setting last bit
Or the more general solution (doesn't care if answer is signed or unsigned)
int answer = 0; // or unsigned int answer = 0;
size_t len = strlen(buffer);
for(int i = len - 1; i > 0; --i)
{
if(buffer[i] == '1')
answer |= 1 << len - 1 - i;
}
edit
I also found an error on your conversion to string:
char buffer[32];
...
i++;
buffer[i] = '\0';
The buffer hold 32 chars, one for each bit. There is no room left for the
0-terminating byte there, also with i++ you are overflowing the buffer, i
would be 33, so you are overflowing by 2.
If you are not going to treat buffer as a string (no strcpy, no strcmp,
no printf), then you don't have to store the terminating '\0'. Remove the
buffer[i] = '\0'; and that's it.
However you do print it as a string, so you would have to declare buffer as
char buffer[33];
and remove the i++ before buffer[i] = '\0';.
In that case, you would need to change the for loops as well, to
for(i = sizeof(buffer) - 2; i >= 0; --i)
and
for(i = sizeof(buffer) - 2; i > 0; --i)
or strlen(buffer) - 1 instead of sizeof(buffer) - 2 (in case you do the
convertion on another function and you pass the pointer to buffer.