使用C以二进制表示打印int

我正在寻找一个函数，允许我打印int的二进制表示形式

char *int2bin(int a)
{
 char *str,*tmp;
 int cnt = 31;
 str = (char *) malloc(33); /*32 + 1 , because its a 32 bit bin number*/
 tmp = str;
 while ( cnt > -1 ){
      str[cnt]= '0';
      cnt --;
 }
 cnt = 31;
 while (a > 0){
       if (a%2==1){
           str[cnt] = '1';
        }
      cnt--;
        a = a/2 ;
 }
 return tmp;

}

但是当我打电话的时候

printf("a %s",int2bin(aMask)) // aMask = 0xFF000000

我得到的输出像

0000000000000000000000000000 XTPYY（和一组未知字符）

这是函数中的一个缺陷，还是我正在打印字符数组的地址或其他什么？对不起，我看不出哪里出了问题

注意：代码来自

---

编辑：仅供参考，这不是家庭作业，我正在尝试用一种不熟悉的语言调试其他人的图像处理例程。但是，如果因为这是一个基本概念而被标记为家庭作业，那么就公平竞争。

您的字符串不是以null结尾的。请确保在字符串末尾添加一个

'\0'

字符；或者，您可以分配用

calloc

替换

malloc

，这将使返回给您的内存归零

顺便说一下，此代码还有其他问题：

• 使用时，它会在您调用它时分配内存，让调用方负责

  free（）

  调用分配的字符串。如果您只是在

  printf

  调用中调用它，就会泄漏内存
• 它对数字进行两次传递，这是不必要的。您可以在一个循环中完成所有操作

这里有一个您可以使用的替代实现

#include <stdlib.h>
#include <limits.h>

char *int2bin(unsigned n, char *buf)
{
    #define BITS (sizeof(n) * CHAR_BIT)

    static char static_buf[BITS + 1];
    int i;

    if (buf == NULL)
        buf = static_buf;

    for (i = BITS - 1; i >= 0; --i) {
        buf[i] = (n & 1) ? '1' : '0';
        n >>= 1;
    }

    buf[BITS] = '\0';
    return buf;

    #undef BITS
}

第二个参数是指向要在其中存储结果字符串的缓冲区的指针。如果没有缓冲区，则可以传递

NULL

，

int2bin

将写入

静态

缓冲区并将其返回给您。与原始实现相比，此方法的优点是调用方不必担心

free（）

ing返回的字符串

缺点是只有一个静态缓冲区，因此后续调用将覆盖以前调用的结果。您无法保存多个调用的结果供以后使用。此外，它不是线程安全的，这意味着如果您从不同线程以这种方式调用函数，它们可能会相互碰撞字符串。如果有可能，您将我需要传入你自己的缓冲区，而不是传入

NULL

，就像这样：

char str[33];
int2bin(0xDEADBEEF, str);
puts(str);

有几件事：

int f = 32;
int i = 1;
do{
  str[--f] = i^a?'1':'0';
}while(i<<1);

intf=32；
int i=1；
做{
str[--f]=i^a？'1'：'0'；
}而（我有两件事：

NUL字符放在哪里？我看不到设置了
'\0'
的地方
Int是有符号的，0xFF000000将被解释为负值。因此
while（a>0）
将立即为false
旁白：内部的malloc函数很难看。为int2bin提供一个缓冲区怎么样？
这里有另一个选项，它在传递分配的缓冲区时更优化。确保它的大小正确

// buffer must have length >= sizeof(int) + 1
// Write to the buffer backwards so that the binary representation
// is in the correct order i.e.  the LSB is on the far right
// instead of the far left of the printed string
char *int2bin(int a, char *buffer, int buf_size) {
    buffer += (buf_size - 1);

    for (int i = 31; i >= 0; i--) {
        *buffer-- = (a & 1) + '0';

        a >>= 1;
    }

    return buffer;
}

#define BUF_SIZE 33

int main() {
    char buffer[BUF_SIZE];
    buffer[BUF_SIZE - 1] = '\0';

    int2bin(0xFF000000, buffer, BUF_SIZE - 1);

    printf("a = %s", buffer);
}

编码的两个简单版本（通过轻度重新格式化复制）

#包括
/*将n打印为二进制数*/
无效打印位示例（int n）
{
无符号整数i；
i=1>=1；
}
}
/*将n打印为二进制数*/
无效打印位（整数n）
{
无符号整数i，步长；
如果（0==n）/*为了简单起见，我将0视为特例*/
{
printf（“0000”）；
返回；
}
i=1=4；/*四人一组*/
而（步骤>=n）
{
i>>=4；
步骤>>=4；
}
/*此时，i是大于或等于n的两个的最小幂*/
而（i>0）
{
如果（n&i）
printf（“1”）；
其他的
printf（“0”）；
i>>=1；
}
}
int main（int argc，char*argv[]）
{
int i；
对于（i=0；i<32；++i）
{
printf（“%d=”，i）；
//打印位示例（i）；
打印位（i）；
printf（“\n”）；
}
返回0；
}
一些建议：


null终止字符串
不要使用幻数
检查
malloc（）的返回值

不要强制转换
malloc（）的返回值

使用二进制运算而不是算术运算，因为您对二进制表示感兴趣
没有必要循环两次

代码如下：

#include <stdlib.h>
#include <limits.h>

char * int2bin(int i)
{
    size_t bits = sizeof(int) * CHAR_BIT;

    char * str = malloc(bits + 1);
    if(!str) return NULL;
    str[bits] = 0;

    // type punning because signed shift is implementation-defined
    unsigned u = *(unsigned *)&i;
    for(; bits--; u >>= 1)
        str[bits] = u & 1 ? '1' : '0';

    return str;
}

#包括
#包括
字符*int2bin（inti）
{
大小\u t位=sizeof（int）*字符\u位；
char*str=malloc（位+1）；
如果（！str）返回NULL；
str[bits]=0；
//类型双关，因为有符号移位是实现定义的
无符号u=*（无符号*）&i；
对于（；位--；u>>=1）
str[bits]=u&1？'1'：'0'；
返回str；
}
无效打印\u二进制（int n）{
如果（n==0 | | n==1）
cout>1）；
cout这里有一个简单的算法

void decimalToBinary (int num) {

        //Initialize mask
        unsigned int mask = 0x80000000;
        size_t bits = sizeof(num) * CHAR_BIT;

        for (int count = 0 ;count < bits; count++) {

            //print
            (mask & num ) ? cout <<"1" : cout <<"0";

            //shift one to the right
            mask = mask >> 1;
        }
    }

void十进制数（int num）{
//初始化掩码
无符号整数掩码=0x8000000；
大小\u t位=大小（num）*字符\u位；
for（int count=0；count#包括
内部主（空）{
int a，i，k=1；
int arr[32]；\\n获取大小为32的数组
for（i=0；i//这就是当我们的老师要求我们这样做时我所做的

int main (int argc, char *argv[]) {

    int number, i, size, mask; // our input,the counter,sizeofint,out mask

    size = sizeof(int);
    mask = 1<<(size*8-1);
    printf("Enter integer: ");
    scanf("%d", &number);
    printf("Integer is :\t%d 0x%X\n", number, number);
    printf("Bin format :\t");
    for(i=0 ; i<size*8 ;++i ) {
        if ((i % 4 == 0) && (i != 0))  {
            printf(" ");
        }

        printf("%u",number&mask ? 1 : 0);

        number = number<<1;
    }
    printf("\n");

    return (0);
} 

intmain（intargc，char*argv[]）{
int number，i，size，mask；//我们的输入，计数器，sizeofint，out mask
大小=sizeof（int）；
mask=1这是我制作的，以二进制代码的形式显示一个整数，它每4位分开：

int getal = 32;             /** To determain the value of a bit 2^i , intergers are 32bits long**/
int binairy[getal];         /** A interger array to put the bits in **/
int i;                      /** Used in the for loop **/
for(i = 0; i < 32; i++)
{
    binairy[i] = (integer >> (getal - i) - 1) & 1;
}

int a , counter = 0;
for(a = 0;a<32;a++)
{
    if (counter == 4)
    {
        counter = 0;
        printf(" ");
    }
   printf("%i", binairy[a]);
   teller++;
}

int getal=32；/**为了确定位2^i的值，整数的长度为32位**/
int binairy[getal]；/**一个用于放入位的整数数组**/
int i；/**用于for循环**/
对于（i=0；i<32；i++）
{
二进制[i]=（整数>>（getal-i）-1&1；
}
int a，计数器=0；
对于（a=0；a
#包括
//y包含/ /使用这一点，如果您在VisualC++中运行代码，则Linux不使用
//我有这个库。我用它作为getch（）来保存输入字符的屏幕。
无效显示位（int）；
int main（）
{
国际贸易编号；
printf（“\n要转换为二进制的输入编号\n”）；
scanf（“%d”和“否”）；
显示位（否）；
//getch（）；
void decimalToBinary (int num) {

        //Initialize mask
        unsigned int mask = 0x80000000;
        size_t bits = sizeof(num) * CHAR_BIT;

        for (int count = 0 ;count < bits; count++) {

            //print
            (mask & num ) ? cout <<"1" : cout <<"0";

            //shift one to the right
            mask = mask >> 1;
        }
    }

#include <stdio.h>
int main(void) {

    int a,i,k=1;
    int arr[32]; \\ taken an array of size 32

    for(i=0;i <32;i++) 
    {
        arr[i] = 0;   \\initialised array elements to zero
    }

    printf("enter a number\n");
    scanf("%d",&a);  \\get input from the user

    for(i = 0;i < 32 ;i++)
    {
        if(a&k)    \\bit wise and operation
        {
            arr[i]=1;
        }
        else
        {
            arr[i]=0;
        }
        k = k<<1; \\left shift by one place evry time
    }
    for(i = 31 ;i >= 0;i--)
    {
        printf("%d",arr[i]);   \\print the array in reverse
    }

    return 0;
}

int main (int argc, char *argv[]) {

    int number, i, size, mask; // our input,the counter,sizeofint,out mask

    size = sizeof(int);
    mask = 1<<(size*8-1);
    printf("Enter integer: ");
    scanf("%d", &number);
    printf("Integer is :\t%d 0x%X\n", number, number);
    printf("Bin format :\t");
    for(i=0 ; i<size*8 ;++i ) {
        if ((i % 4 == 0) && (i != 0))  {
            printf(" ");
        }

        printf("%u",number&mask ? 1 : 0);

        number = number<<1;
    }
    printf("\n");

    return (0);
} 

int getal = 32;             /** To determain the value of a bit 2^i , intergers are 32bits long**/
int binairy[getal];         /** A interger array to put the bits in **/
int i;                      /** Used in the for loop **/
for(i = 0; i < 32; i++)
{
    binairy[i] = (integer >> (getal - i) - 1) & 1;
}

int a , counter = 0;
for(a = 0;a<32;a++)
{
    if (counter == 4)
    {
        counter = 0;
        printf(" ");
    }
   printf("%i", binairy[a]);
   teller++;
}

#include<stdio.h>
//#include<conio.h>  // use this if you are running your code in visual c++,      linux don't 
                     // have this library. i have used it for getch() to hold the screen for input char.

void showbits(int);
int main()
{
    int no;
    printf("\nEnter number to convert in binary\n");
    scanf("%d",&no);
    showbits(no);
//  getch();        // used to hold screen... 
                    // keep code as it is if using gcc. if using windows uncomment #include & getch()
    return 0;   

}
void showbits(int n)
{
    int i,k,andmask;

    for(i=15;i>=0;i--)
    {
        andmask = 1 << i;
        k = n & andmask;

        k == 0 ? printf("0") : printf("1");
    }

}

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

char *intToBinary(int z, int bit_length){

    int div;
    int counter = 0;
    int counter_length = (int)pow(2, bit_length);

    char *bin_str = calloc(bit_length, sizeof(char));

    for (int i=counter_length; i > 1; i=i/2, counter++) {
        div = z % i;
        div = div / (i / 2);
        sprintf(&bin_str[counter], "%i", div);
    }

    return bin_str;
}

int main(int argc, const char * argv[]) {

    for (int i = 0; i < 256; i++) {
        printf("%s\n", intToBinary(i, 8)); //8bit but you could do 16 bit as well
    }

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

void    print_int(int i)
{
    int j = -1;
    while (++j < 32)
        putchar(i & (1 << j) ? '1' : '0');
    putchar('\n');
}

int main(void)
{
    int i = -1;
    while (i < 6)
        print_int(i++);
    return (0);
}

#define GRN "\x1B[32;1m"
#define NRM "\x1B[0m"

void    print_int(int i)
{
    int j = -1;
    while (++j < 32)
    {
        if (i & (1 << j))
            printf(GRN "1");
        else
            printf(NRM "0");
    }
    putchar('\n');
}

11111111111111111111111111111111
00000000000000000000000000000000
10000000000000000000000000000000
01000000000000000000000000000000
11000000000000000000000000000000
00100000000000000000000000000000
10100000000000000000000000000000

#include <stdio.h>

#define BITS_SIZE 8

void
int2Bin ( int a )
{
  int i = BITS_SIZE - 1;

   /*
    * Tests each bit and prints; starts with 
    * the MSB
    */
  for ( i; i >= 0; i-- )
  {
    ( a & 1 << i ) ?  printf ( "1" ) : printf ( "0" );
  }
  return;
}

int
main ()
{
  int d = 5;

  printf ( "Decinal: %d\n", d );
  printf ( "Binary: " );
  int2Bin ( d );
  printf ( "\n" );

  return 0;
}

#include<stdio.h>

int binario(int x, int bits)
{
    int matriz[bits];
    int resto=0,i=0;
    float rest =0.0 ;
    for(int i=0;i<8;i++)
    {
        resto = x/2;
        rest = x%2;
        x = resto;
        if (rest>0)
        {
            matriz[i]=1;
        }
        else matriz[i]=0;
    }
    for(int j=bits-1;j>=0;j--)
    {
        printf("%d",matriz[j]);
    }
    printf("\n");
}
int main()
{
    int num,bits;
    bits = 8;
    for (int i = 0; i < 256; i++)
    {
        num = binario(i,bits);
    }
    return 0;
}

void printBits(int val){
    for(unsigned int mask = 0x80000000; mask; mask >>= 1){
         printf("%d", !!(mask & val));
    }
}