Simple C function returns nonsense - c

Question

I need to make simple function that converts binary number (string) to decimal number (long). When it returns result, it's nonsense. I've tried to return all others variables and it returned correct numbers. There is something wrong with my result variable.
#include "stdio.h"
#include "string.h"
#include "math.h"
long bintodec(const char *bin_num) {
long DIGIT, SUBTOTAL, RESULT = 0, I, LEN;
LEN = strlen(bin_num);
for(I = 0; I != LEN; I++) {
sscanf(&bin_num[I], "%li", &DIGIT);
SUBTOTAL = DIGIT * pow(2, LEN - I - 1);
RESULT = RESULT + SUBTOTAL;
}
return RESULT;
}
main() {
clrscr();
printf("%li", bintodec("101"));
getch();
}

Answer 1

sscanf is expecting a C string:
During the first iteration it receives "101" and 101 * 4 is 404
During the second iteration it receives 01 and 1 * 2 is 2
During the third iteration it receives 1 and 1 * 1 is 1
404 + 2 + 1 is 407 which must be the nonsense you are seeing
What you want is to convert each character:
DIGIT = bin_num[I] - '0';

Answer 2

You can convert string to long in one go, no need to iterate in loop. Changing your code like below can give you desired output
#include <stdio.h>
#include <string.h>
#include <math.h>
long bintodec(const char *bin_num)
{
long DIGIT, SUBTOTAL, RESULT = 0, I, LEN, REM;
LEN = strlen(bin_num);
sscanf(bin_num, "%li", &DIGIT);
printf("DIGIT = %li\n", DIGIT);
for (I = 0; I < LEN; I++)
{
REM = DIGIT%10;
RESULT += REM * pow(2, I);
DIGIT /= 10;
}
return RESULT;
}
int main() {
printf("%li", bintodec("101"));
}

Answer 3

Rather than debug your code, I'll present a more elegant solution. Consider:
long bintodec(const char *bin_num)
{
long sum = 0;
for (; *bin_num != '\0'; bin_num++) /* move pointer through string */
{
sum <<= 1; /* shift bits left (meaningless on first pass) */
sum |= (*bin_num == '1'); /* conditionally tack on new least significant bit */
}
return sum;
}
Some notes:
The key point is that the bits that encode integer type variables are identical to the binary sequence that you pass in as a string. Thus: bitwise operators. The only ones we need here are left bit-shift, which shifts each of the underlying bits one place to the left, and bitwise-or, which logically or's the bits of two numbers against one another. The equivalent representations render valid a pictorial understanding of the problem.
Rather than having to pass through the entire string to determine its length, and using that to inform the pow function, we can slot incoming bits in on the right.
Here's what's going on within the for loop:
1st pass:
sum <<= : 00000 /* more zero's contained in a long */
string: "10101"
ptr: ^
sum |= : 00001
2nd pass:
sum: 00010
string: "10101"
ptr: ^
sum: 00010
3rd pass:
sum: 00100
string: "10101"
ptr: ^
sum: 00101
... and so forth.
In general, rather than invoking
pow(2, arg)
you should leverage the bit-shift operator, which exactly accomplishes multiplication by some power of two. (Appending a zero is multiplication by 10 in base 10).