Printing a number in binary in C

Question

I wrote a short function whose purpose is simple: Print the binary representation of number to the console. I also aim to be as portable as possible, hence my use of CHAR_BIT and + instead of | in case the character encoding for '0' happens to be odd. Is my code as good and portable as I intended?

#include <stdio.h>
#include <limits.h>
#define SIZE (sizeof(unsigned long long)*CHAR_BIT)
int putb(const unsigned long long n) {
    char b[SIZE+1];
    for (unsigned i = SIZE; i--; b[i^SIZE-1] = ((char)(n>>i)&1)+'0');
    b[SIZE] = 0;
    return puts(b);
}

Answer 1

The obvious portability problem is that we have b[i^SIZE-1] where I'd expect b[SIZE-1-i]. That looks like an error of judgement: it produces the same results when SIZE is an exact power of 2, but not otherwise.

Instead of the SIZE preprocessor macro, I'd probably use a constant within the function:

    static const size_t length = sizeof n * CHAR_BIT;

If you do stick with the macro, consider #undef SIZE afterwards so it's available to other code.

As a style issue, I don't like the for loop with empty body on the same line. That looks more like code-golf than something that's intended to be readable - especially with the "work" of the loop stuffed into the control expression.

We really want the cast to char to happen to the sum, since char+char yields int. That said, gcc -pedantic -Wconversion doesn't complain without it.

I would write the character constant 0 as '\0' to better convey the intent. That's especially important as we have '0' close by.

You might find it easier, clearer and more efficient to work backwards from the least-significant bit:

int putb(unsigned long long n)
{
    char b[(sizeof n * CHAR_BIT) + 1];
    char *p = b + sizeof b;
    *--p = '\0';
    for (; p-- > b;  n >>= 1) {
        *p = '0' + (char)(n & 1);
    }
    return puts(b);
}

This gives the option of a version that doesn't print leading zeros (and therefore modified to accept any size integer):

#include <stdint.h>

int putb(uintmax_t n)
{
    char b[(sizeof n * CHAR_BIT) + 1];
    char *p = b + sizeof b;
    *--p = '\0';
    do {
        *--p = '0' + (n & 1);
    } while (n >>= 1);
    return puts(p);
}

This one is trivially modified to add a 0b prefix, should that be desired.

Answer 2

Is my code as good and portable as I intended?

Not quite.

---

C23

Use specifier "%b".

#include <stdio.h>
#include <limits.h>
printf("%0*llb\n", ULLONG_WIDTH, n);  // Print all bits
printf("%llb\n", n);  // Print significant bits

---

For highly portability C99 onward

• OP used a constant sized buffer - good. Variable length arrays since C11 are optionally supported.

• Do not assume no padding bits as with sizeof(unsigned long long)*CHAR_BIT. The number of value bits in an unsigned long long depends on ULLONG_MAX.

#include <stdio.h>
#include <limits.h>

// https://stackoverflow.com/a/4589384/2410359
/* Number of bits in inttype_MAX, or in any (1<<k)-1 where 0 <= k < 2040 */
#define IMAX_BITS(m) ((m)/((m)%255+1) / 255%255*8 + 7-86/((m)%255+12))
#define SIZE (IMAX_BITS(ULLONG_MAX))
...

Consider simply code such as below which looks at the least significant bit per iteration.

int putb(unsigned long long n) {
    char b[SIZE+1];
    b[SIZE] = '\0';
    for (unsigned i = SIZE; i-- > 0; ) {
      b[i] = (char) ((n&1) + '0');
      n >>= 1;
    }
    return puts(b);
}

---

Pre-C99

There is no unsigned long long.