Is there a printf converter to print in binary format?

W

William Whyte

Hacky but works for me:

#define BYTE_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c"
#define BYTE_TO_BINARY(byte)  \
  (byte & 0x80 ? '1' : '0'), \
  (byte & 0x40 ? '1' : '0'), \
  (byte & 0x20 ? '1' : '0'), \
  (byte & 0x10 ? '1' : '0'), \
  (byte & 0x08 ? '1' : '0'), \
  (byte & 0x04 ? '1' : '0'), \
  (byte & 0x02 ? '1' : '0'), \
  (byte & 0x01 ? '1' : '0')

printf("Leading text "BYTE_TO_BINARY_PATTERN, BYTE_TO_BINARY(byte));

For multi-byte types

printf("m: "BYTE_TO_BINARY_PATTERN" "BYTE_TO_BINARY_PATTERN"\n",
  BYTE_TO_BINARY(m>>8), BYTE_TO_BINARY(m));

You need all the extra quotes unfortunately. This approach has the efficiency risks of macros (don't pass a function as the argument to BYTE_TO_BINARY) but avoids the memory issues and multiple invocations of strcat in some of the other proposals here.

And has the advantage also to be invocable multiple times in a printf which the ones with static buffers can't.

I've taken the liberty to change the %d to %c, because it should be even faster (%d has to perform digit->char conversion, while %c simply outputs the argument

Posted an expanded version of this macro with 16, 32, 64 bit int support: stackoverflow.com/a/25108449/432509

Note that this approach is not stack friendly. Assuming int is 32-bits on system, printing single 32-bit value will require space for 32 * 4-byte values; total of 128 bytes. Which, depending on stack size, may or may not be an issue.

its important to add parentheses around byte in the macro or you could run into problems when sending an operation BYTE_TO_BINARY(a | b) -> a | b & 0x01 != (a | b) & 0x01

i

ib.

Print Binary for Any Datatype

// Assumes little endian
void printBits(size_t const size, void const * const ptr)
{
    unsigned char *b = (unsigned char*) ptr;
    unsigned char byte;
    int i, j;
    
    for (i = size-1; i >= 0; i--) {
        for (j = 7; j >= 0; j--) {
            byte = (b[i] >> j) & 1;
            printf("%u", byte);
        }
    }
    puts("");
}

Test:

int main(int argv, char* argc[])
{
    int i = 23;
    uint ui = UINT_MAX;
    float f = 23.45f;
    printBits(sizeof(i), &i);
    printBits(sizeof(ui), &ui);
    printBits(sizeof(f), &f);
    return 0;
}

Suggest size_t i; for (i=size; i-- > 0; ) to avoid size_t vs. int mis-match.

Could someone please elaborate on the logic behind this code?

Take each byte in ptr (outer loop); then for each bit the current byte (inner loop), mask the byte by the current bit (1 << j). Shift that right resulting in a byte containing 0 (0000 0000b) or 1 (0000 0001b). Print the resulting byte printf with format %u. HTH.

@ZX9 Notice that the suggested code used > with size_t and not the >= of your comment to determine when to terminate the loop.

@ZX9 Still a useful original comment of yours as coders do need to be careful considering the edge case use of > and >= with unsigned types. 0 is an unsigned edge case and commonly occurs, unlike signed math with less common INT_MAX/INT_MIN.

E

EvilTeach

Here is a quick hack to demonstrate techniques to do what you want.

#include <stdio.h>      /* printf */
#include <string.h>     /* strcat */
#include <stdlib.h>     /* strtol */

const char *byte_to_binary
(
    int x
)
{
    static char b[9];
    b[0] = '\0';

    int z;
    for (z = 128; z > 0; z >>= 1)
    {
        strcat(b, ((x & z) == z) ? "1" : "0");
    }

    return b;
}

int main
(
    void
)
{
    {
        /* binary string to int */

        char *tmp;
        char *b = "0101";

        printf("%d\n", strtol(b, &tmp, 2));
    }

    {
        /* byte to binary string */

        printf("%s\n", byte_to_binary(5));
    }
    
    return 0;
}

This is certainly less "weird" than custom writing an escape overload for printf. It's simple to understand for a developer new to the code, as well.

A few changes: strcat is an inefficient method of adding a single char to the string on each pass of the loop. Instead, add a char *p = b; and replace the inner loop with *p++ = (x & z) ? '1' : '0'. z should start at 128 (2^7) instead of 256 (2^8). Consider updating to take a pointer to the buffer to use (for thread safety), similar to inet_ntoa().

@EvilTeach: You're using a ternary operator yourself as a parameter to strcat()! I agree that strcat is probably easier to understand than post-incrementing a dereferenced pointer for the assignment, but even beginners need to know how to properly use the standard library. Maybe using an indexed array for assignment would have been a good demonstration (and will actually work, since b isn't reset to all-zeros each time you call the function).

Random: The binary buffer char is static, and is cleared to all zeros in the assignment. This will only clear it the first time it's run, and after that it wont clear, but instead use the last value.

Also, this should document that the previous result will be invalid after calling the function again, so callers should not try to use it like this: printf("%s + %s = %s", byte_to_binary(3), byte_to_binary(4), byte_to_binary(3+4)).

D

DGentry

There isn't a binary conversion specifier in glibc normally.

It is possible to add custom conversion types to the printf() family of functions in glibc. See register_printf_function for details. You could add a custom %b conversion for your own use, if it simplifies the application code to have it available.

Here is an example of how to implement a custom printf formats in glibc.

warning: 'register_printf_function' is deprecated [-Wdeprecated-declarations] There is a new function to do the same, though: register_printf_specifier(). An example of the new usage can be found here: codereview.stackexchange.com/q/219994/200418

P

Peter Mortensen

You could use a small table to improve speed1. Similar techniques are useful in the embedded world, for example, to invert a byte:

const char *bit_rep[16] = {
    [ 0] = "0000", [ 1] = "0001", [ 2] = "0010", [ 3] = "0011",
    [ 4] = "0100", [ 5] = "0101", [ 6] = "0110", [ 7] = "0111",
    [ 8] = "1000", [ 9] = "1001", [10] = "1010", [11] = "1011",
    [12] = "1100", [13] = "1101", [14] = "1110", [15] = "1111",
};

void print_byte(uint8_t byte)
{
    printf("%s%s", bit_rep[byte >> 4], bit_rep[byte & 0x0F]);
}

1 I'm mostly referring to embedded applications where optimizers are not so aggressive and the speed difference is visible.

it works! but what is that syntax used to define bit_rep ?

This code looks great. But how would you update this code to handle uint16_t, uint32_t and uint64_t?

@Robk, 4, 8 and 16 %ss and the same number of bit_rep[word >> 4K & 0xF..F] arguments should do. Although I would argue 16 string prints for a 64-bit number is probably not going to be any faster than looping 64 times and outputting 0/1.

i

isrnick

Print the least significant bit and shift it out on the right. Doing this until the integer becomes zero prints the binary representation without leading zeros but in reversed order. Using recursion, the order can be corrected quite easily.

#include <stdio.h>

void print_binary(unsigned int number)
{
    if (number >> 1) {
        print_binary(number >> 1);
    }
    putc((number & 1) ? '1' : '0', stdout);
}

To me, this is one of the cleanest solutions to the problem. If you like 0b prefix and a trailing new line character, I suggest wrapping the function.

Online demo

you also should use unsigned int number, because when the given number is negative, the function enters in a never-ending recursive call.

More efficient approach, since in ASCII, '0'+1='1': putc('0'+(number&1), stdout);

I've changed the function to also work with int values equal or less than 0.

pass following value 0x80 to your function, the result is not as intended.

i

ideasman42

Based on @William Whyte's answer, this is a macro that provides int8,16,32 & 64 versions, reusing the INT8 macro to avoid repetition.

/* --- PRINTF_BYTE_TO_BINARY macro's --- */
#define PRINTF_BINARY_PATTERN_INT8 "%c%c%c%c%c%c%c%c"
#define PRINTF_BYTE_TO_BINARY_INT8(i)    \
    (((i) & 0x80ll) ? '1' : '0'), \
    (((i) & 0x40ll) ? '1' : '0'), \
    (((i) & 0x20ll) ? '1' : '0'), \
    (((i) & 0x10ll) ? '1' : '0'), \
    (((i) & 0x08ll) ? '1' : '0'), \
    (((i) & 0x04ll) ? '1' : '0'), \
    (((i) & 0x02ll) ? '1' : '0'), \
    (((i) & 0x01ll) ? '1' : '0')

#define PRINTF_BINARY_PATTERN_INT16 \
    PRINTF_BINARY_PATTERN_INT8              PRINTF_BINARY_PATTERN_INT8
#define PRINTF_BYTE_TO_BINARY_INT16(i) \
    PRINTF_BYTE_TO_BINARY_INT8((i) >> 8),   PRINTF_BYTE_TO_BINARY_INT8(i)
#define PRINTF_BINARY_PATTERN_INT32 \
    PRINTF_BINARY_PATTERN_INT16             PRINTF_BINARY_PATTERN_INT16
#define PRINTF_BYTE_TO_BINARY_INT32(i) \
    PRINTF_BYTE_TO_BINARY_INT16((i) >> 16), PRINTF_BYTE_TO_BINARY_INT16(i)
#define PRINTF_BINARY_PATTERN_INT64    \
    PRINTF_BINARY_PATTERN_INT32             PRINTF_BINARY_PATTERN_INT32
#define PRINTF_BYTE_TO_BINARY_INT64(i) \
    PRINTF_BYTE_TO_BINARY_INT32((i) >> 32), PRINTF_BYTE_TO_BINARY_INT32(i)
/* --- end macros --- */

#include <stdio.h>
int main() {
    long long int flag = 1648646756487983144ll;
    printf("My Flag "
           PRINTF_BINARY_PATTERN_INT64 "\n",
           PRINTF_BYTE_TO_BINARY_INT64(flag));
    return 0;
}

This outputs:

My Flag 0001011011100001001010110111110101111000100100001111000000101000

For readability you may want to add a separator for eg:

My Flag 00010110,11100001,00101011,01111101,01111000,10010000,11110000,00101000

This is excellent. Is there a particular reason for printing the bits starting with Least Significant Bits?

how would you recommend adding the comma?

Would add a grouped version of PRINTF_BYTE_TO_BINARY_INT# defines to optionally use.

i

ib.

Here's a version of the function that does not suffer from reentrancy issues or limits on the size/type of the argument:

#define FMT_BUF_SIZE (CHAR_BIT*sizeof(uintmax_t)+1)

char *binary_fmt(uintmax_t x, char buf[static FMT_BUF_SIZE])
{
    char *s = buf + FMT_BUF_SIZE;
    *--s = 0;
    if (!x) *--s = '0';
    for (; x; x /= 2) *--s = '0' + x%2;
    return s;
}

Note that this code would work just as well for any base between 2 and 10 if you just replace the 2's by the desired base. Usage is:

char tmp[FMT_BUF_SIZE];
printf("%s\n", binary_fmt(x, tmp));

Where x is any integral expression.

Yes, you can do that. But it's really bad design. Even if you don't have threads or reentrancy, the caller has to be aware that the static buffer is being reused, and that things like char *a = binary_fmt(x), *b = binary_fmt(y); will not work as expected. Forcing the caller to pass a buffer makes the storage requirement explict; the caller is of course free to use a static buffer if that's really desired, and then the reuse of the same buffer becomes explicit. Also note that, on modern PIC ABIs, static buffers usually cost more code to access than buffers on the stack.

That's still a bad design. It requires an extra copying step in those cases, and it's no less expensive than having the caller provide the buffer even in cases where copying wouldn't be required. Using static storage is just a bad idiom.

Having to pollute the namespace of either the preprocessor or variable symbol table with an unnecessary extra name that must be used to properly size the storage that must be allocated by every caller, and forcing every caller to know this value and to allocate the necessary amount of storage, is bad design when the simpler function-local storage solution will suffice for most intents and purposes, and when a simple strdup() call covers 99% of the rest of uses.

Here we're going to have to disagree. I can't see how adding one unobtrusive preprocessor symbol comes anywhere near the harmfulness of limiting the usage cases severely, making the interface error-prone, reserving permanent storage for the duration of the program for a temporary value, and generating worse code on most modern platforms.

I don't advocate micro-optimizing without reason (i.e. measurements). But I do think performance, even if it's on the micro-gain scale, is worth mentioning when it comes as a bonus along with a fundamentally superior design.

R

Robotbugs

Quick and easy solution:

void printbits(my_integer_type x)
{
    for(int i=sizeof(x)<<3; i; i--)
        putchar('0'+((x>>(i-1))&1));
}

Works for any size type and for signed and unsigned ints. The '&1' is needed to handle signed ints as the shift may do sign extension.

There are so many ways of doing this. Here's a super simple one for printing 32 bits or n bits from a signed or unsigned 32 bit type (not putting a negative if signed, just printing the actual bits) and no carriage return. Note that i is decremented before the bit shift:

#define printbits_n(x,n) for (int i=n;i;i--,putchar('0'|(x>>i)&1))
#define printbits_32(x) printbits_n(x,32)

What about returning a string with the bits to store or print later? You either can allocate the memory and return it and the user has to free it, or else you return a static string but it will get clobbered if it's called again, or by another thread. Both methods shown:

char *int_to_bitstring_alloc(int x, int count)
{
    count = count<1 ? sizeof(x)*8 : count;
    char *pstr = malloc(count+1);
    for(int i = 0; i<count; i++)
        pstr[i] = '0' | ((x>>(count-1-i))&1);
    pstr[count]=0;
    return pstr;
}

#define BITSIZEOF(x)    (sizeof(x)*8)

char *int_to_bitstring_static(int x, int count)
{
    static char bitbuf[BITSIZEOF(x)+1];
    count = (count<1 || count>BITSIZEOF(x)) ? BITSIZEOF(x) : count;
    for(int i = 0; i<count; i++)
        bitbuf[i] = '0' | ((x>>(count-1-i))&1);
    bitbuf[count]=0;
    return bitbuf;
}

Call with:

// memory allocated string returned which needs to be freed
char *pstr = int_to_bitstring_alloc(0x97e50ae6, 17);
printf("bits = 0b%s\n", pstr);
free(pstr);

// no free needed but you need to copy the string to save it somewhere else
char *pstr2 = int_to_bitstring_static(0x97e50ae6, 17);
printf("bits = 0b%s\n", pstr2);

I'm testing this and it looks like both *int_to_bitstring_ methods do not calculate the results properly, or am I missing something? printbits works fine. Also, for decimals larger than 32 results of static and alloc methods begins to differ. Not much experience in C and working with bits yet.

i

ib.

const char* byte_to_binary(int x)
{
    static char b[sizeof(int)*8+1] = {0};
    int y;
    long long z;

    for (z = 1LL<<sizeof(int)*8-1, y = 0; z > 0; z >>= 1, y++) {
        b[y] = (((x & z) == z) ? '1' : '0');
    }
    b[y] = 0;

    return b;
}

Nice solution. I would change some stuff though. I.e. going backward in the string so that input of any size could be handled properly.

All those 8s should be replaced by CHAR_BIT.

I like that id does not use string libraries of any kind and thus can be used in an embedding setting easily

using static variables is really bad for this function. imagine printf(byte_to_binary(1), byte_to_binary(5)), where one call would override the string from the other call