Is there a printf converter to print in binary format

Question

I can print with printf as a hex or octal number   Is there a format tag to print as binary  or arbitrary base     I am running gcc   printf   d  x  o n   10  10  10     prints  10 A 12 n  print   b n   10      prints   b n

User · Answer

No standard and portable way   Some implementations provide itoa    but it s not going to be in most  and it has a somewhat crummy interface   But the code is behind the link and should let you implement your own formatter pretty easily

User · Answer

Here s how I did it for an unsigned int  void printb unsigned int v        unsigned int i  s   1 lt  lt   sizeof v  lt  lt 3 -1      s   only most significant bit at 1     for  i   s  i  i gt  gt  1  printf   d   v  amp  i    0

User · Answer

I optimized the top solution for size and C  -ness  and got to this solution   inline std  string format binary unsigned int x        static char b 33       b 32      0        for  int z   0  z  lt  32  z              b 31-z      x gt  gt z   amp  0x1     1     0              return b

User · Answer

Use below function   void conbin int num             if num    0                        conbin num  gt  gt  1                    if  num  amp  1               printf  1                              else              printf  0

User · Answer

The following recursive function might be useful   void bin int n           Step 1        if  n  gt  1          bin n 2          Step 2        printf   d   n   2

User · Answer

This code should handle your needs up to 64  bits  I created two functions  pBin and pBinFill  Both do the same thing  but pBinFill fills in the leading spaces with the fill character provided by its last argument  The test function generates some test data  then prints it out using the pBinFill function   define kDisplayWidth 64  char  pBin long int x char  so      char s kDisplayWidth 1     int i   kDisplayWidth    s i--    0x00      terminate string   do       fill in array from right to left     s i--     x  amp  1     1     0       determine bit     x  gt  gt   1      shift right 1 bit     while  x  gt  0     i        point to last valid character   sprintf so   quot  s quot   s i       stick it in the temp string string   return so     char  pBinFill long int x  char  so  char fillChar         fill in array from right to left   char s kDisplayWidth 1     int i   kDisplayWidth    s i--    0x00      terminate string   do       fill in array from right to left     s i--     x  amp  1     1     0       x  gt  gt   1      shift right 1 bit     while  x  gt  0     while  i  gt   0  s i--    fillChar      fill with fillChar    sprintf so   quot  s quot   s     return so     void test       char so kDisplayWidth 1       working buffer for pBin   long int val   1    do       printf  quot  ld   t t  lx   t t0b s n quot   val  val  pBinFill val  so   0         val    11      generate test data     while  val  lt  100000000      Output  00000001    0x000001    0b00000000000000000000000000000001 00000011    0x00000b    0b00000000000000000000000000001011 00000121    0x000079    0b00000000000000000000000001111001 00001331    0x000533    0b00000000000000000000010100110011 00014641    0x003931    0b00000000000000000011100100110001 00161051    0x02751b    0b00000000000000100111010100011011 01771561    0x1b0829    0b00000000000110110000100000101001 19487171   0x12959c3    0b00000001001010010101100111000011

User · Answer

I liked the code by paniq  the static buffer is a good idea  However it fails if you want multiple binary formats in a single printf   because it always returns the same pointer and overwrites the array    Here s a C style drop-in that rotates pointer on a split buffer   char   format binary unsigned int x         define MAXLEN 8    width of output format      define MAXCNT 4    count per printf statement     static char fmtbuf  MAXLEN 1  MAXCNT       static int count   0      char  b      count   count   MAXCNT   1      b    amp fmtbuf  MAXLEN 1  count       b MAXLEN      0       for  int z   0  z  lt  MAXLEN  z      b MAXLEN-1-z      x gt  gt z   amp  0x1     1     0         return b

User · Answer

One statement generic conversion of any integral type into the binary string representation using standard library    include  lt bitset gt  MyIntegralType  num   10  print   s n       std  bitset lt sizeof num    8 gt  num  to string   insert 0   0b   c str         prints  0b1010 n    Or just  std  cout  lt  lt  std  bitset lt sizeof num    8 gt  num

User · Answer

It might be not very efficient but it s quite simple  Try this   tmp1   1  while inint tmp1  gt  1        tmp1  lt  lt   1    do       printf   d   tmp2 inint tmp1       inint -  tmp1 tmp2    while  tmp1  gt  gt   1   gt  0   printf

User · Answer

The following function returns binary representation of given unsigned integer using pointer arithmetic without leading zeros    const char  toBinaryString unsigned long num        static char buffer CHAR BIT sizeof num  1       char  pBuffer    amp buffer sizeof buffer -1        do  --pBuffer    0     num  amp  1       while  num  gt  gt   1       return pBuffer      Note that there is no need to explicity set NUL terminator  because buffer repesents an object with static storage duration  that is already filled with all-zeros   This can be easily adapted to unsigned long long  or another unsigned integer  by simply modifing type of num formal parameter   The CHAR BIT requires  lt limits h gt  to be included   Here is an example usage   int main void        printf   gt  gt  gt  20s lt  lt  lt  n   toBinaryString 1        printf   gt  gt  gt  -20s lt  lt  lt  n   toBinaryString 254        return 0      with its desired output as    gt  gt  gt                    1 lt  lt  lt   gt  gt  gt 11111110             lt  lt  lt

User · Answer

I just want to post my solution  It s used to get zeroes and ones of one byte  but calling this function few times can be used for larger data blocks  I use it for 128 bit or larger structs  You can also modify it to use size t as input parameter and pointer to data you want to print  so it can be size independent  But it works for me quit well as it is   void print binary unsigned char c     unsigned char i1    1  lt  lt   sizeof c  8-1     for   i1  i1  gt  gt   1        printf   d   c amp i1   0      void get binary unsigned char c  unsigned char bin       unsigned char i1    1  lt  lt   sizeof c  8-1    i2 0   for   i1  i1 gt  gt  1  i2          bin i2      c amp i1   0

User · Answer

A small utility function in C to do this while solving a bit manipulation problem  This goes over the string checking each set bit using a mask  1 lt   void printStringAsBinary char   input        char   temp   input      int i   7  j  0       int inputLen   strlen input           Go over the string  check first bit  bit by bit and print 1 or 0               for  j   0  j  lt  inputLen  j              printf   n            while  i gt  0                if   temp  amp   1  lt  lt  i                    printf  1                  else                   printf  0                              i--                    temp   temp 1          i   7          printf   n

User · Answer

My solution returns an int which can then be used in printf  It can also return the bits in big endian or little endian order    include  lt stdio h gt   include  lt stdint h gt   int binary uint8 t i int bigEndian        int j 0 m   bigEndian   1   10000000      while  i                j  m  i 2           if  bigEndian  m  10  else m  10          i  gt  gt   1            return j     int main         char buf    ABCDEF       printf   nbig endian           for  int i 0  i lt 5  i    printf   08d   binary buf i  1        printf   nwee endian           for  int i 0  i lt 5  i    printf   08d   binary buf i  0        getchar        return 0      Outputs  big endian   01000001 01000010 01000011 01000100 01000101 01000110 wee endian   10000010 01000010 11000010 00100010 10100010 01100010

User · Answer

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  quot  s n quot   binary fmt x  tmp     Where x is any integral expression

User · Answer

Is there a printf converter to print in binary format   There s no standard printf format specifier to accomplish  binary  output  Here s the alternative I devised when I needed it   Mine works for any base from 2 to 36  It fans the digits out into the calling frames of recursive invocations  until it reaches a digit smaller than the base  Then it  traverses  backwards  filling the buffer s forwards  and returning  The return value is the size used or -1 if the buffer isn t large enough to hold the string   int conv rad  int num  int rad  char  s  int n        char  vec    0123456789   ABCDEFGHIJKLM   NOPQRSTUVWXYZ       int off      if  n    0  return 0      if  num  lt  rad     s   vec num   return 1        off   conv rad num rad  rad  s  n       if   off    n      off    -1   return -1      s off    vec num rad       return off 1      One big caveat  This function was designed for use with  Pascal -style strings which carry their length around  Consequently conv rad  as written  does not nul-terminate the buffer  For more general C uses  it will probably need a simple wrapper to nul-terminate  Or for printing  just change the assignments to putchar  s

User · Answer

Convert an int to it s binary representation     char  int2bin int num  int pad     char  str   malloc sizeof char     pad 1      if  str       str pad    0      while  --pad gt  0        str pad    num  amp  1    1     0       num  gt  gt   1           else      return          return str        example usage     printf  The number 5 in binary is  s   int2bin 5  4        The number 5 in binary is 0101

User · Answer

Based on  William Whyte s answer  this is a macro that provides int8 16 32  amp  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   amp  0x80ll     1     0             i   amp  0x40ll     1     0             i   amp  0x20ll     1     0             i   amp  0x10ll     1     0             i   amp  0x08ll     1     0             i   amp  0x04ll     1     0             i   amp  0x02ll     1     0             i   amp  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   gt  gt  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   gt  gt  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   gt  gt  32   PRINTF BYTE TO BINARY INT32 i     --- end macros ---      include  lt stdio h gt  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

User · Answer

const char  byte to binary int x        static char b sizeof int  8 1     0       int y      long long z       for  z   1LL lt  lt sizeof int  8-1  y   0  z  gt  0  z  gt  gt   1  y              b y       x  amp  z     z     1     0              b y    0       return b

User · Answer

Based on  ideasman42 s suggestion in his answer  this is a macro that provides int8 16 32  amp  64 versions  reusing the INT8 macro to avoid repetition      --- PRINTF BYTE TO BINARY macro s ---     define PRINTF BINARY SEPARATOR  define PRINTF BINARY PATTERN INT8   c c c c c c c c   define PRINTF BYTE TO BINARY INT8 i              i   amp  0x80ll     1     0             i   amp  0x40ll     1     0             i   amp  0x20ll     1     0             i   amp  0x10ll     1     0             i   amp  0x08ll     1     0             i   amp  0x04ll     1     0             i   amp  0x02ll     1     0             i   amp  0x01ll     1     0     define PRINTF BINARY PATTERN INT16       PRINTF BINARY PATTERN INT8               PRINTF BINARY SEPARATOR              PRINTF BINARY PATTERN INT8  define PRINTF BYTE TO BINARY INT16 i        PRINTF BYTE TO BINARY INT8  i   gt  gt  8     PRINTF BYTE TO BINARY INT8 i   define PRINTF BINARY PATTERN INT32       PRINTF BINARY PATTERN INT16              PRINTF BINARY SEPARATOR              PRINTF BINARY PATTERN INT16  define PRINTF BYTE TO BINARY INT32 i        PRINTF BYTE TO BINARY INT16  i   gt  gt  16   PRINTF BYTE TO BINARY INT16 i   define PRINTF BINARY PATTERN INT64          PRINTF BINARY PATTERN INT32              PRINTF BINARY SEPARATOR              PRINTF BINARY PATTERN INT32  define PRINTF BYTE TO BINARY INT64 i        PRINTF BYTE TO BINARY INT32  i   gt  gt  32   PRINTF BYTE TO BINARY INT32 i     --- end macros ---      include  lt stdio h gt  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 can change   define PRINTF BINARY SEPARATOR to  define PRINTF BINARY SEPARATOR     or  define PRINTF BINARY SEPARATOR      This will output   My Flag 00010110 11100001 00101011 01111101 01111000 10010000 11110000 00101000   or  My Flag 00010110 11100001 00101011 01111101 01111000 10010000 11110000 00101000

User · Answer

There is also an idea to convert the number to hexadecimal format and then to decode each hexadecimal cipher to four  bits   ones and zeros   sprintf can do bit operations for us   const char  binary int n      static const char binnums 16  5       0000   0001   0010   0011        0100   0101   0110   0111   1000   1001   1010   1011   1100   1101   1110   1111       static const char  hexnums    0123456789abcdef     static char inbuffer 16   outbuffer 4 16     const char  i    sprintf inbuffer   x  n      hexadecimal n - gt  inbuffer   for i inbuffer   i  0    i       for each hexadecimal cipher     int d   strchr hexnums  i  - hexnums     store its decimal value to d     char  o   outbuffer  i-inbuffer  4     shift four characters in outbuffer     sprintf o   s  binnums d       place binary value of d there       return strchr outbuffer  1       omit leading zeros    puts binary 42       outputs 101010

User · Answer

Some runtimes support   b  although that is not a standard   Also see here for an interesting discussion   http   bytes com forum thread591027 html  HTH

User · Answer

This is my take on this subject  Advantages to most other examples   Uses putchar   which is more efficient than printf   or even  although not as much  puts   Split into two parts  expected to have code inlined  which allows extra efficiency  if wanted  Is based on very fast RISC arithmetic operations  that includes not using division and multiplication   Disadvantages to most examples   Code is not very straightforward  print binary size   modifies the input variable without a copy   Note  The best outcome for this code relies on using -O1 or higher in gcc or equivalent  Here s the code      inline void print binary sized unsigned int number  unsigned int digits            static char ZERO    0           int digitsLeft   digits                   do              putchar ZERO     number  gt  gt  digitsLeft   amp  1             while digitsLeft--              void print binary unsigned int number            int digitsLeft   sizeof number    8                   while    number  gt  gt  digitsLeft   amp  1   amp  amp  digitsLeft               digitsLeft--                    print binary sized number  digitsLeft

User · Answer

Next will show to you memory layout    include  lt limits gt   include  lt iostream gt   include  lt string gt   using namespace std   template lt class T gt  string binary text T dec  string byte separator              char  pch    char   amp dec      string res      for  int i   0  i  lt  sizeof T   i              for  int j   1  j  lt  8  j                  res append pch i   amp  1    1     0                pch i     2                    res append byte separator             return res     int main         cout  lt  lt  binary text 5   lt  lt  endl      cout  lt  lt  binary text  1   lt  lt  endl       return 0

User · Answer

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  gt  gt  4   bit rep byte  amp  0x0F        1 I m mostly referring to embedded applications where optimizers are not so aggressive and the speed difference is visible

User · Answer

Yet another approach to print in binary  Convert the integer first   To print 6 in binary  change 6 to 110  then print  110    Bypasses char buf   issues  printf   format specifiers  flags   amp  fields like   08lu      lX  still readily usable  Not only binary  base 2   this method expandable to other bases up to 16  Limited to smallish integer values      include  lt stdint h gt   include  lt stdio h gt   include  lt inttypes h gt   unsigned long char to bin10 char ch      unsigned char uch   ch    unsigned long sum   0    unsigned long power   1    while  uch        if  uch  amp  1          sum    power             power    10     uch    2        return sum     uint64 t uint16 to bin16 uint16 t u      uint64 t sum   0    uint64 t power   1    while  u        if  u  amp  1          sum    power              power    16      u    2        return sum     void test void      printf   lu n   char to bin10 0xF1         11110001   printf     PRIX64   n   uint16 to bin16 0xF731         1111011100110001

User · Answer

There is no formatting function in the C standard library to output binary like that  All the format operations the printf family supports are towards human readable text

User · Answer

None of the previously posted answers are exactly what I was looking for  so I wrote one  It is super simple to use  B with the printf        File    main c    Author  Techplex Engineer       Created on February 14  2012  9 16 PM       include  lt stdio h gt   include  lt stdlib h gt   include  lt printf h gt   include  lt math h gt   include  lt string h gt   static int printf arginfo M const struct printf info  info  size t n  int  argtypes            quot  M quot  always takes one argument  a pointer to uint8 t 6          if  n  gt  0            argtypes 0    PA POINTER            return 1     static int printf output M FILE  stream  const struct printf info  info  const void  const  args        int value   0      int len       value     int      args 0            Beginning of my code ------------------------------------------------------------     char buffer  50     quot  quot       Is this bad      char buffer2  50     quot  quot       Is this bad      int bits   info- gt width      if  bits  lt   0          bits   8      Default to 8 bits      int mask   pow 2  bits - 1       while  mask  gt  0            sprintf buffer   quot  s quot     value  amp  mask   gt  0    quot 1 quot     quot 0 quot             strcat buffer2  buffer           mask  gt  gt   1            strcat buffer2   quot  n quot           End of my code --------------------------------------------------------------     len   fprintf stream   quot  s quot   buffer2       return len     int main int argc  char   argv        register printf specifier  B   printf output M  printf arginfo M        printf  quot  4B n quot   65        return EXIT SUCCESS

User · Answer

Even for the runtime libraries that DO support  b it seems it s only for integer values   If you want to print floating-point values in binary  I wrote some code you can find at http   www exploringbinary com converting-floating-point-numbers-to-binary-strings-in-c

User · Answer

Use   char buffer  33   itoa value  buffer  2   printf   nbinary   s n   buffer     For more ref   see How to print binary number via printf

User · Answer

m specifies how many of the low bits are shown     Replace m with sizeof n  below for all bits and    remove it from the parameter list if you like   void print binary unsigned long n  unsigned long m        static char show 3     01       unsigned long mask   1ULL  lt  lt   m-1       while mask            putchar show    n amp mask     mask  gt  gt   1            putchar   n

User · Answer

Here s is a very simple one   int print char to binary char ch        int i      for  i 7  i gt  0  i--          printf   hd      ch  amp   1 lt  lt i   gt  gt i        printf   n        return 0

User · Answer

Print bits from any type using less code and resources  This approach has as attributes    Works with variables and literals  Doesn t iterate all bits when not necessary  Call printf only when complete a byte  not unnecessarily for all bits   Works for any type  Works with little and big endianness  uses GCC  defines for checking   Uses typeof   that isn t C standard but is largely defined     include  lt stdio h gt   include  lt stdint h gt   include  lt string h gt    if   BYTE ORDER        ORDER BIG ENDIAN    define for endian size  for  int i   0  i  lt  size    i   elif   BYTE ORDER        ORDER LITTLE ENDIAN    define for endian size  for  int i   size - 1  i  gt   0  --i   else  error  Endianness not detected   endif   define printb value                                                                                                        typeof value   v   value                                    printb  typeof  v      amp  v  sizeof  v                void   printb void  value  size t size            uint8 t byte          size t blen   sizeof byte    8          uint8 t bits blen   1            bits blen      0           for endian size                    byte     uint8 t    value  i                   memset bits   0   blen                   for  int j   0  byte  amp  amp  j  lt  blen    j                            if  byte  amp  0x80                                  bits j     1                           byte  lt  lt   1                                    printf   s    bits                     printf   n       int main void            uint8 t c1   0xff  c2   0x44          uint8 t c3   c1   c2           printb c1           printb  char  0xff           printb  short  0xff           printb 0xff           printb c2           printb 0x44           printb 0x4411ff01           printb  uint16 t  c3           printf   n             return 0      Output      printb  11111111  11111111  00000000 11111111  00000000 00000000 00000000 11111111  01000100  00000000 00000000 00000000 01000100  01000100 00010001 11111111 00000001  00000000 01000011      I have used another approach  bitprint h  to fill a table with all bytes  as bit strings  and print them based on the input index byte  It s worth taking a look

User · Answer

My solution   long unsigned int i  for i   0u  i  lt  sizeof integer    CHAR BIT  i          if integer  amp  LONG MIN          printf  1        else         printf  0        integer  lt  lt   1    printf   n

User · Answer

Quick and easy solution   void printbits my integer type x        for int i sizeof x  lt  lt 3  i  i--          putchar  0    x gt  gt  i-1   amp 1        Works for any size type and for signed and unsigned ints  The   amp 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 gt  gt i  amp 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 lt 1   sizeof x  8   count      char  pstr   malloc count 1       for int i   0  i lt count  i            pstr i     0      x gt  gt  count-1-i   amp 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 lt 1    count gt BITSIZEOF x     BITSIZEOF x    count      for int i   0  i lt count  i            bitbuf i     0      x gt  gt  count-1-i   amp 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

User · Answer

Maybe a bit OT  but if you need this only for debuging to understand or retrace some binary operations you are doing  you might take a look on wcalc  a simple console calculator   With the -b options you get binary output   e g      wcalc -b   256   3    0xff     0b11

User · Answer

include  lt stdio h gt   include  lt conio h gt   void main         clrscr        printf  Welcome n n n        unsigned char x  A       char ch array 8       for int i 0  x  0  i                  ch array i    x  amp  1          x   x  gt  gt 1            for --i  i gt  0  i--          printf   d   ch array i         getch

User · Answer

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

User · Answer

void PrintBinary  int Value  int Places  char  TargetString        int Mask       Mask   1  lt  lt  Places       while  Places--            Mask  gt  gt   1     Preshift  because we did one too many above             TargetString      Value  amp  Mask   1   0              TargetString   0     Null terminator for C string        The calling function  owns  the string      char BinaryString 17       PrintBinary  Value  16  BinaryString   printf   yadda yadda  s yadda    n   BinaryString     Depending on your CPU  most of the operations in PrintBinary render to one or very few machine instructions

User · Answer

void DisplayBinary int n        int arr 8       int top  -1      while  n                if  n  amp  1              arr   top    1          else             arr   top    0           n  gt  gt   1            for  int i   top   i  gt  -1 i--                printf   d  arr i              printf   n

User · Answer

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  lt stdio h gt   void print binary unsigned int number        if  number  gt  gt  1            print binary number  gt  gt  1             putc  number  amp  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

User · Answer

The combination of functions   macro at the end of this answer can help you   Use it like that   float float var   9 4  SHOW BITS float var     Which will output  Variable  float var   01000001 00010110 01100110 01100110  Note that it is very general and can work with pretty much any type  For instance   struct  int a  float b  double c   struct var    1 1 1 1 2   SHOW BITS struct var     Which will output    Variable  struct var   00111111 11110011 00110011 00110011 00110011 00110011 00110011 00110011 00111111 10001100 11001100 11001101 00000000 00000000 00000000 00000001   Here s the code    define SHOW BITS a           printf  Variable   s       a        show bits  amp a  sizeof a         void show uchar unsigned char a        for int i   7  i  gt   0  i-  1           printf   d     a  gt  gt  i   amp  1       void show bits void  a  size t s        unsigned char  p    unsigned char   a      for int i   s-1  i  gt   0   i -  1            show uchar p i            printf                 printf   n

User · Answer

Here is a quick hack to demonstrate the techniques for what you want   include  lt stdio h gt       printf     include  lt string h gt      strcat     include  lt stdlib h gt      strtol     const char  byte to binary int x        static char b 9       b 0      0        int z      for  z   128  z  gt  0  z  gt  gt   1            strcat b    x  amp  z     z     quot 1 quot     quot 0 quot               return b     int main void                     binary string to int            char  tmp          char  b    quot 0101 quot           printf  quot  d n quot   strtol b   amp tmp  2                           byte to binary string            printf  quot  s n quot   byte to binary 5              return 0

User · Answer

void DisplayBinary unsigned int n        int l   sizeof n    8      for  int i   l - 1   i  gt   0  i--            printf   x    n  amp   1  lt  lt  i    gt  gt  i

User · Answer

Here is a small variation of paniq s solution that uses templates to allow printing of 32 and 64 bit integers   template lt class T gt  inline std  string format binary T x        char b sizeof T  8 1     0        for  size t z   0  z  lt  sizeof T  8  z            b sizeof T  8-1-z      x gt  gt z   amp  0x1     1     0        return std  string b       And can be used like   unsigned int value32   0x1e127ad  printf     0x x   s n   value32  format binary value32  c str       unsigned long long value64   0x2e0b04ce0  printf   0x llx   s n   value64  format binary value64  c str        Here is the result     0x1e127ad  00000001111000010010011110101101 0x2e0b04ce0  0000000000000000000000000000001011100000101100000100110011100000

User · Answer

void print bits  uintmax t n        for  size t i   8   sizeof  int   i--    0                 char c          if   n  amp   1UL  lt  lt  i      0              c    1           else             c    0            printf   quot  c quot   c             Not a cover-absolutely-everywhere solution but if you want something quick  and easy to understand  I m suprised no one has proposed this solution yet

User · Answer

Is there a printf converter to print in binary format   The printf   family is only able to print integers in base 8  10  and 16 using the standard specifiers directly   I suggest creating a function that converts the number to a string per code s particular needs   To print in any base  2-36  All other answers so far have at least one of these limitations   Use static memory for the return buffer   This limits the number of times the function may be used as an argument to printf     Allocate memory requiring the calling code to free pointers   Require the calling code to explicitly provide a suitable buffer   Call printf   directly   This obliges a new function for to fprintf    sprintf    vsprintf    etc   Use a reduced integer range    The following has none of the above  limitation   It does require C99 or later and use of  quot  s quot    It uses a compound literal to provide the buffer space   It has no trouble with multiple calls in a printf     include  lt assert h gt   include  lt limits h gt   define TO BASE N  sizeof unsigned  CHAR BIT   1                                    v  compound literal  v  define TO BASE x  b  my to base  char  TO BASE N    quot  quot     x    b       Tailor the details of the conversion function as needed    This one does not display unneeded leading zeros    Use return value  not  buf  char  my to base char buf TO BASE N   unsigned i  int base      assert base  gt   2  amp  amp  base  lt   36     char  s    amp buf TO BASE N - 1      s     0     do       s--       s    quot 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ quot  i   base       i    base      while  i         Could employ memmove here to move the used buffer to the beginning      size t len    amp buf TO BASE N  - s       memmove buf  s  len      return s      include  lt stdio h gt  int main void      int ip1   0x01020304    int ip2   0x05060708    printf  quot  s  s n quot   TO BASE ip1  16   TO BASE ip2  16      printf  quot  s  s n quot   TO BASE ip1  2   TO BASE ip2  2      puts TO BASE ip1  8      puts TO BASE ip1  36      return 0     Output 1020304 5060708 1000000100000001100000100 101000001100000011100001000 100401404 A2F44

User · Answer

Maybe someone will find this solution useful   void print binary int number  int num digits        int digit      for digit   num digits - 1  digit  gt   0  digit--            printf   c   number  amp   1  lt  lt  digit     1     0

User · Answer

Do a function and call it  display binary int n        long int arr 32       int arr counter 0      while n gt  1                arr arr counter    n 2          n  2            for int i arr counter-1 i gt  0 i--                printf   d  arr i

User · Answer

void binario int num      for int i 0 i lt 32 i          num amp  1 lt i    printf  1            printf  0            printf   n

User · Answer

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  gt   0  i--            for  j   7  j  gt   0  j--                byte    b i   gt  gt  j   amp  1              printf  quot  u quot   byte                       puts  quot  quot       Test  int main int argv  char  argc          int i   23      uint ui   UINT MAX      float f   23 45f      printBits sizeof i    amp i       printBits sizeof ui    amp ui       printBits sizeof f    amp f       return 0

User · Answer

Hacky but works for me    define BYTE TO BINARY PATTERN   c c c c c c c c   define BYTE TO BINARY byte        byte  amp  0x80    1     0         byte  amp  0x40    1     0         byte  amp  0x20    1     0         byte  amp  0x10    1     0         byte  amp  0x08    1     0         byte  amp  0x04    1     0         byte  amp  0x02    1     0         byte  amp  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 gt  gt 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

User · Answer

void print ulong bin const unsigned long   const var  int bits            int i            if defined   LP64       defined  LP64                  if   bits  gt  64      bits  lt   0             else                 if   bits  gt  32      bits  lt   0             endif                 return           for i   0  i  lt  bits  i                       printf   lu     var  gt  gt   bits - 1 - i    amp  0x01                 should work - untested

User · Answer

void print binary unsigned int n        unsigned int mask   0         this grotesque hack creates a bit pattern 1000              regardless of the size of an unsigned int        mask    mask     mask  gt  gt  1        for   mask    0  mask  gt  gt   1            putchar  n  amp  mask     1     0

[c] Is there a printf converter to print in binary format?

Examples related to c

Examples related to printf