C，使用printf时的奇怪行为

Question

Here i got a code which prints integer in binary representation

#define BUF_SIZE 33
int main() {
    for (int count = 0; count <=25; count++){

        char buffer[BUF_SIZE];
        buffer[BUF_SIZE - 1] = '\0';

        int2bin(count, buffer, BUF_SIZE - 1);
        printf("%d = %s \n",count, buffer);
    }
}

char *int2bin(int a, char *buffer, int buf_size) {
    buffer += (buf_size - 1);

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

    return buffer;
}

it works great until I'm trying to squeeze some lines of code replacing

int2bin(count, buffer, BUF_SIZE - 1);
printf("%d = %s \n",count, buffer);

with

printf("%d = %s \n",count, int2bin(count, buffer, BUF_SIZE - 1));

It totaly breaks my output with these logs:

805306368 = 00000000000000000000000000000000
805306369 = 00000000000000000000000000000001
805306370 = 00000000000000000000000000000010
805306371 = 00000000000000000000000000000011
805306372 = 00000000000000000000000000000100
805306373 = 00000000000000000000000000000101

and so on...

could you please explain why is that?

Answer 1

At first glance it looks like the first -1 in int2bin() is not necessary (as the loop start of with one -1)

See Scott Mermelstein answer for explanation

Answer 2

First of all, it's a safe bet that the issue isn't with the printf . Let's assume printf works right. The conclusion then is that you're passing different input to it. Working with that, lets look in detail at what you're doing.

In your two-line example, it works because you pass in buffer. Could it be that in your one-line example, you're passing an address that isn't buffer?

Well, in int2bin, you add buf_size - 1 , and then work your way through 32 (From 31 to 0 inclusive) numbers, and should consequently be returning buffer , right?

Wrong.

You're passing in BUF_SIZE - 1 to int2bin , which is 32. Then you're subtracting 1 from that, so you're adding 31 instead of 32, and consequently, not returning buffer.

Easy way to observe this: print out the address of buffer at the start, and the address of buffer at the end of the function.

Easy fixes:

• You could set your first line of int2bin to say buffer += BUF_SIZE - 1 .
• You could simply save buffer s original value and return that
• You could not use a seemingly arbitrary hardcode in your for loop, instead setting i = buf_size .

Basically, epatel's first glance answer is right. My answer just provides more detail.

Answer 3

in int2bin you overwrite the byte before the buffer with an '0'. The compiler have laid the parameter " count " for printf at this place.

Just remove "-1" in your call

printf("%d = %s \n",count, int2bin(count, buffer, BUF_SIZE));

By the was 805306368 is binary

00110000 00000000 00000000 00000000

and

00110000 = 48 = '0'

There is an other defect in your code, loop count depends on buf_size! I would recomment to rewrite it this way.

#define BUF_SIZE sizeof(int)
int main() {
  for (int count = 0; count <=25; count++){

    char buffer[BUF_SIZE + 1];
    buffer[BUF_SIZE] = '\0';

    int2bin(count, buffer, BUF_SIZE);
    printf("%d = %s \n",count, buffer);
  }
}

char *int2bin(int a, char *pBuffer, int buf_size) {
   char *buffer = pBuffer + buf_size;

   for (int i = buf_size; i > 0; i--) { // loop count depends on buf_size!!!
     buffer--;
     *buffer = (a & 1) + '0';
     a >>= 1;
   }

   return pBuffer;
}

Answer 4

You have to call the function as

int2bin(count, buffer, BUF_SIZE)

otherwise the function will write bit-chars from buffer minus 1byte (that's an underflow that put some garbage around in the memory) to buffer + 31 bytes

Answer 5

Your code is rather obscure with down counting loops and "trying to be smarts", such as the fishy *buffer = (a & 1) + '0'; . Bit masking has nothing to do with ASCII numbers so don't mix them in the same operation. Try to make the code simple instead of complicated. That is the true source of your problem.

Rewrite the code in a more readable manner and your bugs will go away.

#include <stdio.h>
#include <stdint.h>

void int_to_bin (char bin[32+1], uint32_t val)
{
  for(int i=0; i<32; i++)
  {
    uint32_t mask = 1 << (32 - 1 - i); // -1 to compensate for zero indexing

    if( (val & mask) != 0)
    {
      bin[i] = '1';
    }
    else
    {
      bin[i] = '0';
    }
  }

  bin[32] = '\0';
}



int main()
{
  char buf[32+1]; 

  int_to_bin(buf, 0xAAAA);
  puts(buf);
  int_to_bin(buf, 0xCAFEBABE);
  puts(buf);
  int_to_bin(buf, 0x12345678);
  puts(buf);
}

Answer 6

Besides whatever might be wrong with buffer_size (the other answers already explain that in good detail). The easiest fix is to add

#include <stdio.h>

char * int2bin(int a, char * buffer, int buf_size);

to the top of your code. That did make it compile & work for me. Both with

int2bin(count, buffer, BUF_SIZE - 1);
printf("%d = %s \n",count, buffer);

and

printf("%d = %s \n", count, int2bin(count, buffer, BUF_SIZE));