Dtyjlui

#include <stdio.h>



void get_bits(unsigned long long* num, char * out, int bytes);



int main(void)

{

    long long x = 0;



    printf("Enter a number: ");

    scanf("%lli", &x);



    char bits[sizeof(unsigned long long)+1] = {0};

    get_bits(&x, bits, 4);



    printf("%d in binary %sn", x, bits);



    return 0;

}



//assumes char array of length 1 greater than 

//number of bits

//EDIT: VERSION WITHOUT MEMCPY AS REMINDED BY @REINDERIEN

//REMOVED aliasing issue

void get_bits(unsigned long long * num, char *out, int bytes)

{

    unsigned long long filter = 0x8000000000000000;

   // unsigned long long *temp = num;



    if(bytes <= 0) return;

    if(bytes > 8) bytes = 8;



    filter = filter >> (8*(sizeof(unsigned long long)-bytes));

    //memcpy(&temp, num, bytes);

    int bits = 8*bytes;

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

        //if(filter & temp)

        //if((filter >> i) & *temp)

        if((filter >> i) & *num)

            out[i] = '1';

        else

            out[i] = '0';



        //temp = temp << 1;

    }

    out[bits] = '';

}

EDIT

Void* removed

Improvements

The posted code requires several loops, divisions, and modulus calculations. While it does solve the problem of representing an integer in binary, the utility may be limited by additional clock cycles.

The code may be optimized and extended to use with other integer representations, including char, short, or long long (or long depending on the size of long).

One drawback of the posted code is the need to reverse bits. Utilizing a mask to filter which bits are set in the number is more efficient.

Alternative Solution

The function get_bits will accept any integer representation.

It will "return," really populate, a character array with up to a 64-bit bit representation of the number.

It NO LONGER relies on memcpy from string.h.

Inputs for get_bits

unsigned long long* *num : a pointer to the memory address of the number to be represented in
binary

char *out : the address of a character array to store the bit representation.

NOTE: This should be of length 1 longer than the number of bits to
be represented

int bytes : number of bytes containing the number to represent in binary

Implementation

Based on the size of the data type of the number to be represented, a mask is established with the highest bit set. This is the variable, filter, of type unsigned long long contained in 64-bits. The input number passed as an unsigned long long*. Using bit shifting, the filter is shifted to the right to align it with the highest bit of the number.

Ex. In hexadecimal, a 16-bit filter would be 0x8000, which in binary is 100000000000000.

Only a single for loop is performed to populate the output string. In each iteration of the loop, a bit-wise AND is performed with filter and *temp. The result of this expression is either 0 or non-zero. The result is 0 only, when the highest order bit of temp is 0. The position in the output string is set to 1 if non-zero or 0 otherwise.

At the end of each iteration the filter is shifted incrementally by 1 more bit to the right.

Ex. In binary, if temp is 1010, then temp << 1 is 0100. (a suitable filter would be 1000 in binary).

if I have used the elements of this language properly. Suggestions for improvement are welcome.

• Good use of sizeof(int) to form a right size buffer rather than assuming some magic number.

Improvements ideas

Negative numbers

Code only prints a 'n' (and no visible text) when the int is negative.

Unnecessary code

The special test for 0 can be deleted ...

if (number == 0) {

    printf("0n");

    return;

}

... by using a following

do  {

  ...

} while (number > 0);

instead of

while (number > 0) {

  ...

}

Assumed char size

Code assumes 8 bits/char with sizeof(int) * 8. This is very common yet not specified in C. Instead use CHAR_BIT for maximum portability.

#include <limits.h>



// char bits[sizeof(int) * 8 + 1] = {0};

char bits[sizeof(int) * CHAR_BIT + 1] = {0};

Simplified code

To well print negative numbers takes a little work to properly handle all negative values including INT_MIN.

Remember that -number is undefined behavior (UB) when number == INT_MIN.

Simplified code that forms the string right-to-left to skip the reverse step.

#include <limits.h>

#include <stdio.h>



void print_decimal_number_binary_alt(int number) {

  int n = number;

  char bits[sizeof(int) * CHAR_BIT + 2];  // + 2 for '-' and '';



  char *s = &bits[sizeof bits - 1];  // Point to last array element;

  *s = '';



  do {

    s--;

    *s = '0' + (n % 2 != 0);

    n /= 2;

  } while (n);



  if (number < 0) {

    *(--s) = '-';

  }



  puts(s);

}

Sample

int main(void) {

  print_decimal_number_binary_alt(0);

  print_decimal_number_binary_alt(1);

  print_decimal_number_binary_alt(-1);

  print_decimal_number_binary_alt(42);

  print_decimal_number_binary_alt(INT_MAX);

  print_decimal_number_binary_alt(INT_MIN);

}

Output

0

1

-1

101010

1111111111111111111111111111111

-10000000000000000000000000000000

I'm adding another answer in a different direction from my previous one, both to show the OP some alternative techniques, and to illustrate an adaptation of @RJM's method.

Here's the code; it's quite simple:

#include <stdint.h>

#include <stdio.h>



static void printBinary(const uint8_t *restrict num, int bytes) {

    for (int p = bytes - 1; p >= 0; p--) {

        uint8_t x = num[p];

        for (int i = 0; i < 8; i++) {

            putchar('0' | (x >> 7));

            x <<= 1;

        }

    }

}



int main() {

    int64_t x;

    for (;;) {

        puts("Enter an integer: ");

        if (scanf("%lld", &x) == 1)

            break;

        while (getchar() != 'n');

    }



    printBinary((uint8_t*)&x, sizeof(x));

    putchar('n');



    return 0;

}

Things to observe as compared to the OP's code (and RJM's code):

• There are no calls to malloc or memcpy.


• The result is not stored in memory; it's output directly to stdout.


• The input integer has a primitive form of validation. The program will loop until scanf succeeds.


• The input integer supports 64 bits instead of 32.


• The output routine supports integers of any length, with the assumption that the integer is little-endian.


• The bit sequence reversal is done directly in the decoding loop, rather than as a separate step.


• There is no need for a "filter" (mask) variable.


• The main loop does not need an if.

A brief word on computers

This code assumes a few things that are true in the vast (vast) majority of cases:

• The processor is little-endian


• There are 8 bits per byte


• The caller cares about the "real" binary representation of data in the processor, rather than the "logical" binary translation of variables

The last point applies to both signed and floating-point data. This code does not care to write "-10", because that's not how the processor stores the data. This code will show either one's-complement (never seen these days) or two's-complement (always seen these days) machine representations of the data.

Similarly, this code does not show "-0.5" as "-0.1" in binary. To do so would make the code more complicated.

A brief word on restrict

For the dirty details, do some reading here.

restrict is a promise that no aliasing is done; i.e. that this pointer is the only way to access the data it points to, to enable some optimizations that wouldn't otherwise be possible. In the context of this program, if it's self-contained, the keyword won't have any effect. restrict enables some optimizations that would make it invalid for other code to modify the same data. Even in a context where there is only one pointer argument to the function, restrict has meaning. A multi-threaded program could alias the data, or (though not the case here) this function could call out to another function that already holds an alias. These aliases and restrict cannot coexist.

I'm happy to explain any aspect of this approach for the purposes of education.

A decent compromise between readability and execution speed is this:

#include <stdint.h>

#include <string.h>



char* i32tostr (int32_t n, char str[32+1])

{

  const char NIBBLE_LOOKUP[16][4] = 

  {

    "0000", "0001", "0010", "0011",

    "0100", "0101", "0110", "0111",

    "1000", "1001", "1010", "1011",

    "1100", "1101", "1110", "1111",

  };



  char* ptr = str;

  for(uint32_t bit=32; bit>0; bit-=4)

  {

    uint32_t shift = bit - 4;

    uint32_t mask = 0xFu << shift;

    size_t index = (n & mask) >> shift;

    memcpy(ptr, NIBBLE_LOOKUP[index], 4); 

    ptr+=4;

  }

  *ptr = '';



  return str;

}

This reads the number 4 bits (a nibble) at a time from MSB to LSB. It masks out a nibble, then does a table look-up to get the pre-calculated string.

As it happens, a 4 byte string can be copied in a single instruction on 32 bit computers. Note the intentional subtle detail: const char NIBBLE_LOOKUP[16][4] instead of const char* NIBBLE_LOOKUP[16]. This means that the null terminator in the string literals is not stored and we can't use strcpy. Instead we use the significantly faster memcpy.

The local variables in the for loop are there for readability and don't affect performance. I could as well have written it as

for(uint32_t shift=28; shift>0; shift-=4)

{

  memcpy(ptr, NIBBLE_LOOKUP[(n & 0xFu<<shift) >> shift], 4); 

  ptr+=4;

}

But that's much harder to read and yields exactly the same machine code anyway.

In terms of execution speed, this should be much faster than parsing bit by bit and building up a string that way. The x86 disassembly looks pretty good; branch-free and cache-friendly: https://godbolt.org/z/DgJcVC.

Complete example:

#include <stdint.h>

#include <string.h>



char* i32tostr (int32_t n, char str[32+1])

{

  const char NIBBLE_LOOKUP[16][4] = 

  {

    "0000", "0001", "0010", "0011",

    "0100", "0101", "0110", "0111",

    "1000", "1001", "1010", "1011",

    "1100", "1101", "1110", "1111",

  };



  char* ptr = str;

  for(uint32_t bit=32; bit>0; bit-=4)

  {

    uint32_t shift = bit - 4;

    uint32_t mask = 0xFu << shift;

    size_t index = (n & mask) >> shift;

    memcpy(ptr, NIBBLE_LOOKUP[index], 4); 

    ptr+=4;

  }

  *ptr = '';



  return str;

}



#include <stdio.h>

#include <limits.h>



int main (void)

{

  char str[32+1];



  puts(i32tostr(0,str));

  puts(i32tostr(1,str));

  puts(i32tostr(-1,str));

  puts(i32tostr(INT_MIN,str));

  puts(i32tostr(INT_MAX,str));

}

Output:

00000000000000000000000000000000

00000000000000000000000000000001

11111111111111111111111111111111

10000000000000000000000000000000

01111111111111111111111111111111