在C语言中将字符串转换为二进制

我正在尝试将字符串转换为C中的二进制。此函数必须返回字符串（char*），如“010010101”等。我还想打印返回的内容。我不能肯定这个代码

作用

char*stringToBinary（char*s）
{
如果（s==NULL）返回0；/*无输入字符串*/
char*binary=malloc（sizeof（s）*8）；
strcpy（二进制“”）；
char*ptr=s；
int i；
对于（；*ptr！=0；++ptr）
{
/*对字符的每一位执行按位和*/
对于（i=7；i>=0；--i）{
（*ptr&1无需对输入进行任何假设，只需打印字节中的位：

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

#包括
#包括
#包括
#包括
#包括
char*stringToBinary（char*s）
{
如果（s==NULL）{
//NULL可能是0，但您不能确定它是否为空
返回NULL；
}
//获取不带NUL的字符串长度
尺寸=标准长度；
//我们不能在这里这样做，为什么？
//如果（slen==0）{返回s；}
errno=0；
//分配“slen”（字符串中不带NUL的字符数）
//乘以“char”中的位数加上NUL的一个字节
//在返回值的末尾
char*binary=malloc（slen*char\u位+1）；
if（二进制==NULL）{
fprintf（stderr，“malloc在stringToBinary（%s）中失败）：%s\n”，s，strerror（errno））；
返回NULL；
}
//最后，我们可以把我们的捷径从上面这里
如果（slen==0）{
*二进制='\0'；
返回二进制；
}
char*ptr；
//注意开头
char*start=binary；
int i；
//循环输入字符
对于（ptr=s；*ptr！='\0'；ptr++）{
/*对字符的每一位执行按位和*/
//循环输入字符位
对于（i=CHAR_位-1；i>=0；i--，二进制++）{
*binary=（*ptr&1我不编译，但我希望这能启发您
因此：
字符是8位的。
xxxxxxxx
使用掩码比较每个位更容易、更快
XXXXXXX X
&
00000001
仅当第一位为1时，才为真。
接下来是
XXXXXX XX
&
00000010

char*stringToBinary（char*s）
{   
//变量。
字符*aux，*二进制，掩码；
整数大小，i，y；
如果（s==NULL）{
//如果arg为null，则无需执行任何操作。
返回NULL；
}
//计算str的大小。
尺寸=strlen（s）；
//alloc包含答案的str。
二进制=malloc（（大小*8）+1）；
//如果没有记忆，无事可做。
if（二进制==NULL）{
//没有记忆
返回NULL；
}
//保存参数的副本。
aux=s；
//对于str arg中的每个字符。
对于（i=0；i而言，您的代码似乎基本上是正确的。您只是在错误的数量上进行了修改。下面是更正：

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

malloc（sizeof（s）*8）；
永远不要信任用户（调用者）。为什么要为8个指针分配空间？每个字符有8位，如果我有一个包含10个字母的字符串，它的意思是10*8？不是吗？
s
是指向
char
的指针
sizeof s
是
char*/code>的大小（可能是4或8个字节）@ventsyv什么？ASCII是7位。代码转储没有多大帮助。请添加一些注释或其他解释，说明此代码如何解决OP的问题。否定表示最短的答案？我现在将添加注释。thks表示建议
strcat（bynary，“1”）
：
bynary
指向未初始化的内容。并键入名称。
aux++
-->
aux++
，您的过程也是反向结果。
\include“stdlib.h”==>\include
\include“stdio.h”=>\include
\include
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;
}

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

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