Question

嗨，我对编码很新，我真的需要帮助。基本上我有一个十进制值，我把它转换为二进制值。使用这种方法

long decimalToBinary(long n) 
{
    int remainder; 
    long binary = 0, i = 1;

    while(n != 0) 
    {
        remainder = n%2;
        n = n/2;
        binary= binary + (remainder*i);
        i = i*10;
    }
    return binary;
}

我想将二进制文件的每个字符放入数组中自己的空间。但是，我似乎无法保存字符串数组中返回值的数字。我认为这与将long转换为string有关，但我可能错了！这是我到目前为止所拥有的。我不想使用sprintf（）;我不希望打印我只想要存储在其中的值的值，以便if条件可以读取它。任何帮助将不胜感激！

int decimalG = 24;
long binaryG = decimalToBinary(decimalG);
char myStringG[8] = {binaryG};
for( int i = 0; i<8; i++)
{
     if (myStringG[i] == '1' )
    {
     T1();
    }
    else 
    {
    T0();
 }
 }

在这种情况下，由于十进制数是24，二进制数将是11000，因此它应该执行函数T1（）; 2次，T0（）6次。但它没有这样做，我似乎无法找到将保存的值存储在数组中的答案 * Ps Itoa（）;功能也不是一种选择。提前致谢！：）

Answer 1

由于帖子被标记arm使用malloc()可能不是最好的方法，尽管最简单。如果你坚持使用数组：

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

int decimalToBinary(long n, char out[], int len)
{
  long remainder;
  // C arrays are zero based
  len--;
  // TODO: check if the input is reasonable
  while (n != 0) {
    // pick a bit
    remainder = n % 2;
    // shift n one bit to the right
    // It is the same as n = n/2 but
    // is more telling of what you are doing:
    // shifting the whole thing to the right
    // and drop the least significant bit
    n >>= 1;
    // Check boundaries! Always!
    if (len < 0) {
      // return zero for "Fail"
      return 0;
    }
    // doing the following four things at once:
    // cast remainder to char
    // add the numerical value of the digit "0"
    // put it into the array at place len
    // decrement len
    out[len--] = (char) remainder + '0';
  }
  // return non-zero value for "All OK"
  return 1;
}

// I don't know what you do here, but it
// doesn't matter at all for this example
void T0()
{
  fputc('0', stdout);
}

void T1()
{
  fputc('1', stdout);
}

int main()
{
  // your input
  int decimalG = 24;
  // an array able to hold 8 (eight) elements of type char
  char myStringG[8];

  // call decimalToBinary with the number, the array and
  // the length of that array
  if (!decimalToBinary(decimalG, myStringG, 8)) {
    fprintf(stderr, "decimalToBinary failed\n");
    exit(EXIT_FAILURE);
  }
  // Print the whole array
  // How to get rid of the leading zeros is left to you
  for (int i = 0; i < 8; i++) {
    if (myStringG[i] == '1') {
      T1();
    } else {
      T0();
    }
  }
  // just for the optics
  fputc('\n', stdout);
  exit(EXIT_SUCCESS);
}

计算所需的长度很棘手，但如果您知道Micro使用的long的大小（这些天是8,16,32甚至64位），您可以将其作为阵列的最大大小。留下前导零，但这应该不是问题，或者是它？

Answer 2

使用itoa（integer-to-ascii）函数。

http://www.cplusplus.com/reference/cstdlib/itoa/

编辑：更正：

不要成为白痴，请使用itoa（整数到ascii）函数。

http://www.cplusplus.com/reference/cstdlib/itoa/

编辑：

也许我不够清楚。我看到了这句话：

* Ps Itoa（）;功能也不是一种选择。

这是完全不合理的。你想重新发明轮子，但你想要别人这样做吗？你对itoa有什么看法？这是标准的一部分。无论您使用的是什么平台或C版本，它都将永远存在。

Answer 3

要实现目标，您不必将十进制值转换为二进制值：

unsigned decimalG = 24; // Assumed positive, for negative values
                        // have implementation-defined representation
for (; decimalG; decimalG >>= 1) {
    if(decimalG & 1) {
        // Do something
    } else {
        // Do something else
    }
}

或者你可以使用联盟，但我不确定这种方法是否由标准明确定义。

如果您坚持写decimalToBinary，请注意您必须使用数组：

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

char *decimalToBinary(unsigned n);

int
main(void) {
    int decimalG = 15;
    char *binary = decimalToBinary(decimalG);
    puts(binary);
    free(binary);
}

char *
decimalToBinary(unsigned n) {
    // Don't forget to free() it after use!!!
    char *binary = malloc(sizeof(unsigned) * CHAR_BIT + 1);
    if(!binary) return 0;

    size_t i;
    for (i = 0; i < sizeof(unsigned) * CHAR_BIT; i++) {
        binary[i] = '0' + ((n >> i) & 1); // in reverse order
    }
    binary[i] = 0;

    return binary;
}

Answer 4

我想将二进制文件的每个字符都放入其中数组中的空间。但是，我似乎无法保存数字来自我的字符串数组中的返回值。

如果我理解你的要求，有很多方法可以解决这个问题。首先，不需要将数字的二进制表示的结果实际存储在数组中，以根据构成数字的任何给定位的位值来调用T1()或T0()。 / p>

举例24（二进制11000）。如果我正确阅读了您的帖子，请说明：

在这种情况下，因为小数是24，所以二进制将是11000因此它应该执行功能T1() 2次，T0() 6次。

（我不确定您在6次获得的时间，看起来您打算将T0()称为3次

例如，如果您定义了T0和T1，只需告诉您何时调用它们，例如：

void T1 (void) { puts ("T1 called"); }
void T0 (void) { puts ("T0 called"); }

您可以编写一个函数（比如名为callt），为每个T1调用1-bit，为每个T0调用0-bit，如下所示：

void callt (const unsigned long v)
{
    if (!v)  { putchar ('0'); return; };

    size_t sz = sizeof v * CHAR_BIT;
    unsigned long rem = 0;

    while (sz--)
        if ((rem = v >> sz)) {
            if (rem & 1) 
                T1(); 
            else 
                T0();
        }
}

到目前为止，如果您将24传递给函数callt (24)，则输出为：

$ ./bin/dec2bincallt
T1 called
T1 called
T0 called
T0 called
T0 called

（答案结尾处提供的完整示例）

另一方面，如果你真的想将二进制文件的每个字符放入数组中的自己的空间，那么你只需要传递一个数组来捕获位值（'0'和'1'的ASCII字符表示，或0和1）而不是调用T0和T1 （如果要将数组用作字符串，还可以添加几行来处理v=0以及 nul-terminatedating 字符）例如：

/** copy 'sz' bits of the binary representation of 'v' to 's'.
 *  returns pointer to 's', on success, empty string otherwise.
 *  's' must be adequately sized to hold 'sz + 1' bytes.
 */
char *bincpy (char *s, unsigned long v, unsigned sz)
{
    if (!s || !sz) {
        *s = 0;
        return s;
    }
    if (!v) {
        *s = '0';
        *(s + 1) = 0;
        return s;
    }
    unsigned i;

    for (i = 0; i < sz; i++)
        s[i] = (v >> (sz - 1 - i)) & 1 ? '1' : '0';
    s[sz] = 0;

    return s;
}

如果您有任何其他问题，请与我们联系。以下是两个示例程序。两者都将转换（或处理）的数字作为第一个参数作为二进制（默认值：如果没有给出参数，则为24）。第一个只为每个T1调用1-bit，为每个T0调用0-bit：

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>         /* for CHAR_BIT */

void callt (const unsigned long v);
void T1 (void) { puts ("T1 called"); }
void T0 (void) { puts ("T0 called"); }

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

    unsigned long v = argc > 1 ? strtoul (argv[1], NULL, 10) : 24;

    callt (v);

    return 0;
}

void callt (const unsigned long v)
{
    if (!v)  { putchar ('0'); return; };

    size_t sz = sizeof v * CHAR_BIT;
    unsigned long rem = 0;

    while (sz--)
        if ((rem = v >> sz)) {
            if (rem & 1) T1(); else T0();
        }
}

示例使用/输出

$ ./bin/dec2bincallt
T1 called
T1 called
T0 called
T0 called
T0 called

$ ./bin/dec2bincallt 11
T1 called
T0 called
T1 called
T1 called

第二个将值的二进制表示的每个位存储为 nul-terminated 字符串并打印结果：

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

#define BITS_PER_LONG 64    /* define as needed */

char *bincpy (char *s, unsigned long v, unsigned sz);

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

    unsigned long v = argc > 1 ? strtoul (argv[1], NULL, 10) : 24;
    char array[BITS_PER_LONG + 1] = "";

    printf (" values in array: %s\n", bincpy (array, v, 16));

    return 0;
}

/** copy 'sz' bits of the binary representation of 'v' to 's'.
 *  returns pointer to 's', on success, empty string otherwise.
 *  's' must be adequately sized to hold 'sz + 1' bytes.
 */
char *bincpy (char *s, unsigned long v, unsigned sz)
{
    if (!s || !sz) {
        *s = 0;
        return s;
    }
    if (!v) {
        *s = '0';
        *(s + 1) = 0;
        return s;
    }
    unsigned i;

    for (i = 0; i < sz; i++)
        s[i] = (v >> (sz - 1 - i)) & 1 ? '1' : '0';
    s[sz] = 0;

    return s;
}

示例使用/输出

（填充到16位）

$ ./bin/dec2binarray
 values in array: 0000000000011000

$ ./bin/dec2binarray 11
 values in array: 0000000000001011

需要使用C将int转换为字符串

4 个答案: