Dec to bin converter function printing result out backwards - c

Question

As part of an exercise, I have to rewrite a recursive function so that the new function is not recursive. Both functions need to convert positive decimal integer inputs into their binary equivalent.
This is the code using recursion:
void convert(int n) { //recursive
if (n > 0) {
convert(n/2);
printf("%d", n%2);
}
return;
}
Here's my code:
void convert(int n) { //non-recursive
while (n > 0) {
printf("%d", n%2);
n/=2;
}
return;
}
The problem with my code is that, understandably, my binary conversion gets printed out backwards. For example, if I enter the number 8, my function returns 0001, if I enter 2, 01 is returned, etc.
Any suggestions for a quick fix using only the stdio.h library?

Answer 1

Here's a non-recursive version that produces the same result as your recursive version and doesn't require an array:
void convert(int n) {
int s;
for (s = 1; n/s/2 > 0; s *= 2)
;
for (; s >= 1; s /= 2) {
printf("%d", (n/s) % 2);
}
}
This version handles zero and large numbers (but not negative numbers).

Answer 2

You can do this in one loop:
if(num == 0) {
printf("0\n"); // Check for num being 0.
return;
}
num = num < 0 ? num*-1 : num; // Make sure the number has no sign bit.
char first1Found = 0; // Create a check for the first 1 printed.
for (int i = sizeof(num)*8 - 1; i >= 0 ; --i) {
if (num & (1 << i)) { // If its a 1, print it and set the first1Found bool.
printf("1");
first1Found = 1;
} else if(first1Found) { // If its a 0 only print it if its not a leading 0.
printf("0");
}
}
printf("\n");
Here is a live example.
Note: I have used 8 by making an assumption that sizeof returns bytes in a type. This may not be true of all systems and compilers (although should be). A more portable way might be to use CHAR_BIT from <limits.h> as suggested by #chux.

Answer 3

Here's a variant that's explicit about using bit-masking and shifting the location of the mask from the upper end downwards. It behaves like your recursive version, in that it doesn't do negatives or zero.
void convert(int n) {
for(int mask = 1 << (8 * sizeof(n) - 2); mask > 0; mask >>= 1) {
if (mask <= n) {
putchar((n & mask) ? '1' : '0');
}
}
putchar('\n');
}

Answer 4

C99 variation on #Tom Karzes fine answer that handles all + and - values including INT_MIN.
void convertm(int n) {
if (n < 0) {
putchar('-');
} else {
n = -n;
}
// Build up a negative power-of-2 that meets/exceeds `n`
int npow2;
for (npow2 = -1; n/2 <= npow2 ; npow2 *= 2)
;
// For each negative power-of-2 ...
while (npow2) {
putchar(n / npow2 + '0');
n %= npow2;
npow2 /= 2;
}
puts("");
}

Answer 5

A reliable way to print an unpadded binary representation of an unsigned valued (any size capable of fitting within a long unsigned) is:
/** unpadded binary representation of 'v'. */
void binprn (const unsigned long v)
{
if (!v) { putchar ('0'); return; };
size_t sz = sizeof v * CHAR_BIT;
unsigned long rem = 0;
while (sz--)
if ((rem = v >> sz))
putchar ((rem & 1) ? '1' : '0');
}
(CHAR_BIT (usually 8) is provided in limits.h). You do not "need" to use limits.h -- that's just where it CHAR_BIT is normally found. All you need is a constant, you can call it anything you like. I generally just use:
/* CHAR_BIT */
#ifndef CHAR_BIT
#define CHAR_BIT 8
#endif