Convert String To Binary in C

Question

im trying to convert string to binary in C. This function must be return a string(char *) like "010010101" etc. Also i want to print what returned. I cant be sure about this code

FUNCTION

char* stringToBinary(char* s)
{
    if(s == NULL) return 0; /* no input string */
    char *binary = malloc(sizeof(s)*8);
    strcpy(binary,"");
    char *ptr = s;
    int i;

    for(; *ptr != 0; ++ptr)
    {

        /* perform bitwise AND for every bit of the character */
        for(i = 7; i >= 0; --i){
            (*ptr & 1 << i) ? strcat(binary,"1") : strcat(binary,"0");
        }


    }
    
    return binary;
}

Answer 1

Your code seems to be mostly fine. You are only really mallocing the wrong amount. Here it is wth the corrections:

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

char* stringToBinary(char* s) {
    if(s == NULL) return 0; /* no input string */
    size_t len = strlen(s);
    char *binary = malloc(len*8 + 1); // each char is one byte (8 bits) and + 1 at the end for null terminator
    binary[0] = '\0';
    for(size_t i = 0; i < len; ++i) {
        char ch = s[i];
        for(int j = 7; j >= 0; --j){
            if(ch & (1 << j)) {
                strcat(binary,"1");
            } else {
                strcat(binary,"0");
            }
        }
    }
    return binary;
}

Sample runs:

"asdf"           => 01100001011100110110010001100110
"tester"         => 011101000110010101110011011101000110010101110010
"Happy New Year" => 0100100001100001011100000111000001111001001000000100111001100101011101110010000001011001011001010110000101110010

Answer 2

Without any assumptions about the input, just printing the bits in the bytes:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
char *stringToBinary(char *s)
{
  if (s == NULL) {
    // NULL might be 0 but you cannot be sure about it
    return NULL;
  }
  // get length of string without NUL
  size_t slen = strlen(s);

  // we cannot do that here, why?
  // if(slen == 0){ return s;}

  errno = 0;
  // allocate "slen" (number of characters in string without NUL)
  // times the number of bits in a "char" plus one byte for the NUL
  // at the end of the return value
  char *binary = malloc(slen * CHAR_BIT + 1);
  if(binary == NULL){
     fprintf(stderr,"malloc has failed in stringToBinary(%s): %s\n",s, strerror(errno));
     return NULL;
  }
  // finally we can put our shortcut from above here
  if (slen == 0) {
    *binary = '\0';
    return binary;
  }
  char *ptr;
  // keep an eye on the beginning
  char *start = binary;
  int i;

  // loop over the input-characters
  for (ptr = s; *ptr != '\0'; ptr++) {
    /* perform bitwise AND for every bit of the character */
    // loop over the input-character bits
    for (i = CHAR_BIT - 1; i >= 0; i--, binary++) {
      *binary = (*ptr & 1 << i) ? '1' : '0';
    }
  }
  // finalize return value
  *binary = '\0';
  // reset pointer to beginning
  binary = start;
  return binary;
}


int main(int argc, char **argv)
{
  char *output;
  if (argc != 2) {
    fprintf(stderr, "Usage: %s string\n", argv[0]);
    exit(EXIT_FAILURE);
  }
  // TODO: check argv[1]
  output = stringToBinary(argv[1]);
  printf("%s\n", output);

  free(output);
  exit(EXIT_SUCCESS);
}

Answer 3

I dont compile, but i hope this inspire you So: a char is 8 bit. xxxxxxxx compare each bit is easier and faster with a mask xxxxxxxX & 00000001 that is true only if the 1st bit is 1. next will be xxxxxxXx & 00000010

char * stringToBinary( char * s )
{   
    // Variables.
    char * aux, *binary, mask;
    int size, i, y;

    if(s == NULL){
        // If arg is null, nothing to do.
        return NULL;
    }

    // Calculate the size of the str.
    size= strlen(s);
    // alloc the str that contain the answer.
    binary= malloc( (size*8)+1 );
    // If no memory, nothing to do.
    if( binary == NULL ){
        // No memory
        return NULL;
    }

    // save a copy of the arg.
    aux= s;
    // for each char in the str arg.
    for( i=0; i<size; i++ ){
        // In each char to examinate, reset the mask.
        mask= 0x0001;
        // For each bit of a char.
        for( y=0; y<8; y++ ){
            // Compare each bit with the mask.
            if( (*aux) & mask ){
                // add 0 to the answer.
                strcat(bynary,"1");
            }else{
                // add 1 to the answer.
                strcat(bynary,"0");
            }
            // shit the mask 1 pos to left.
            mask= mask<<1;
         }
         aux++
    }
    return binary;
}