Есть ли конвертер printf для печати в двоичном формате?

Нет двоичного спецификатора преобразования в glibc обычно.

возможно добавить пользовательские типы преобразования к printf () семья функций в glibc. См. register_printf_function для деталей. Вы могли добавить пользовательское %b преобразование для своего собственного использования, если оно упрощает код приложения для имения его в наличии.

Вот пример из как реализовать пользовательский printf форматы в glibc.

Возможно, немного OT, но если Вам нужно это только для того, чтобы отладить, чтобы понять или восстановить некоторые бинарные операции, которые Вы делаете, Вы могли бы смотреть на wcalc (простой консольный калькулятор). С-b опциями Вы получаете двоичный выход.

, например,

$ wcalc -b "(256 | 3) & 0xff"
 = 0b11

Некоторое время выполнения поддерживает "%b", хотя это не стандарт.

Также посмотрите здесь для интересного обсуждения:

http://bytes.com/forum/thread591027.html

HTH

Вот быстрый взлом для демонстрации методов, чтобы сделать то, что Вы хотите.

#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;
}

Никакой стандартный и портативный путь.

Некоторые реализации обеспечивают itoa () , но это не будет в большинстве, и это имеет несколько вшивый интерфейс. Но код находится позади ссылки и должен позволить Вам реализовать свое собственное средство форматирования довольно легко.

Нет никакой функции форматирования в стандартной библиотеке C для вывода двоичного файла как этот. Все операции форматирования printf поддержки семьи находятся к читаемому пользователем тексту.

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;
}

Этот код должен обрабатывать ваши потребности до 64 бит. Я создал 2 функции pBin и pBinFill. Оба делают то же самое, но pBinFill заполняет начальные пробелы с помощью fillChar. Тестовая функция генерирует некоторые тестовые данные, а затем распечатывает их с помощью функции.

char* pBinFill(long int x,char *so, char fillChar); // version with fill
char* pBin(long int x, char *so);                   // version without fill
#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 & 1) ? '1':'0';  // determine bit
  x>>=1;  // shift right 1 bit
 } while( x > 0);
 i++;   // point to last valid character
 sprintf(so,"%s",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 & 1) ? '1':'0';
  x>>=1;  // shift right 1 bit
 } while( x > 0);
 while(i>=0) s[i--]=fillChar;    // fill with fillChar 
 sprintf(so,"%s",s);
 return so;
}

void test()
{
 char so[kDisplayWidth+1]; // working buffer for pBin
 long int val=1;
 do
 {
   printf("%ld =\t\t%#lx =\t\t0b%s\n",val,val,pBinFill(val,so,'0'));
   val*=11; // generate test data
 } while (val < 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

Халтурно, но работает для меня:

#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));

Для многобайтовых типов

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

К сожалению, вам нужны все дополнительные кавычки. Этот подход имеет риски эффективности макросов (не передавайте функцию в качестве аргумента BYTE_TO_BINARY), но позволяет избежать проблем с памятью и многократных вызовов strcat в некоторых других предложениях здесь.

Даже для динамических библиотек, которые поддерживают% b, кажется, что это только для целочисленных значений.

Если вы хотите напечатать значения с плавающей запятой в двоичном виде, я написал некоторый код, который вы можете найти на http://www.exploringbinary.com/converting-floating-point-numbers-to-binary-strings-in-c/ .