是否有一个printf转换器打印二进制格式?

小开

C标准库中没有这样输出二进制的格式化函数。printf家族支持的所有格式操作都是针对人类可读的文本。

小开

一些运行时支持“%b”，尽管这不是标准。

也可以在这里看到一个有趣的讨论:

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

HTH

小开

没有标准和便携的方式。

一些实现提供了itoa ()，但大多数实现中都没有，而且它的接口有些糟糕。但是代码在链接后面，应该可以让您非常容易地实现自己的格式化程序。

小开

glibc中通常没有二进制转换说明符。

在glibc中，可以向printf()函数家族添加自定义转换类型。详见register_printf_function。如果可以简化应用程序代码，您可以添加自定义%b转换供自己使用。

下面是如何在glibc中实现自定义printf格式的例子。

小开

这里有一个快速的技巧来演示如何做你想做的事情。

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

小开

可能有点超时，但是如果你只是为了调试来理解或回溯你正在做的一些二进制操作而需要这个，你可以看看wcalc(一个简单的控制台计算器)。使用-b选项可以得到二进制输出。

如。

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

小开

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

小开

即使是支持%b的运行时库，它似乎也只适用于整数值。

如果您想打印二进制的浮点值，我写了一些代码，您可以在http://www.exploringbinary.com/converting-floating-point-numbers-to-binary-strings-in-c/中找到。

小开

这段代码应该处理你的需求高达64位。我创建了两个函数:pBin和pBinFill。两者都做同样的事情，但是pBinFill用最后一个参数提供的fill字符填充前导空格。测试函数生成一些测试数据，然后使用pBinFill函数将其打印出来

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

输出:

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。

小开

void print_ulong_bin(const unsigned long * const var, int bits) {
int i;


#if defined(__LP64__) || defined(_LP64)
if( (bits > 64) || (bits <= 0) )
#else
if( (bits > 32) || (bits <= 0) )
#endif
return;


for(i = 0; i < bits; i++) {
printf("%lu", (*var >> (bits - 1 - i)) & 0x01);
}
}

应该工作-未经测试。

小开

打印任何数据类型的二进制

// 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("");
}

测试:

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

小开

void PrintBinary( int Value, int Places, char* TargetString)
{
int Mask;


Mask = 1 << Places;


while( Places--) {
Mask >>= 1; /* Preshift, because we did one too many above */
*TargetString++ = (Value & Mask)?'1':'0';
}
*TargetString = 0; /* Null terminator for C string */
}

调用函数“拥有”字符串…:

char BinaryString[17];
...
PrintBinary( Value, 16, BinaryString);
printf( "yadda yadda %s yadda...\n", BinaryString);

取决于您的CPU, PrintBinary中的大多数操作呈现给一个或很少几个机器指令。

小开

#include <stdio.h>
#include <conio.h>


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 & 1;
x = x >>1;
}
for(--i; i>=0; i--)
printf("%d", ch_array[i]);


getch();
}

小开

下面是一个不受重入性问题或参数大小/类型限制的函数版本:

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

请注意，这段代码适用于2到10之间的任何底数，只要将2替换为所需的底数。用法是:

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

其中x为任意积分表达式。

小开

/* 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>=0) {
str[pad] = num & 1 ? '1' : '0';
num >>= 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" */