-4

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

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 转换为字符串有关，但我可能是错的！这是我到目前为止所拥有的。我不想使用 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(); 功能也不是一种选择。提前致谢！:)

4

4 回答 4

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

计算所需的长度很棘手，但如果您知道longMicro 使用的大小（现在是 8、16、32 甚至 64 位），您可以将其作为数组的最大大小。留下前导零，但这不应该是一个问题，或者是吗？

于 2016-08-24T02:23:53.673 回答
0

使用itoa(integer-to-ascii) 函数。

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

编辑：更正：

别傻了，使用itoa(integer-to-ascii) 函数。

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

编辑：

也许我不够清楚。我看到那行说：

*PS Itoa(); 功能也不是一种选择。

这是完全不合理的。你想重新发明轮子，但又想让别人去做？你可能对 itoa 有什么看法？这是标准的一部分。无论您的目标是什么平台或您使用的是什么版本的 C，它都会一直存在。

于 2016-08-24T00:52:59.327 回答
0

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

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;
}
于 2016-08-24T02:12:30.413 回答
0

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

如果我理解您的要求，有多种方法可以解决此问题。首先，不需要将数字的二进制表示的结果实际存储在要调用的数组中T1()或T0()基于构成数字的任何给定位的位值。

以您的示例24（二进制11000）为例。如果我正确阅读了您的帖子，您会说：

在这种情况下，由于十进制是24，因此二进制应该是11000执行函数T1() 2times 和T0() 6times 。

（我不确定您在哪里获得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给 function callt (24)，输出将是：

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

（答案末尾提供了完整示例）

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

/** 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）。第一个简单地调用T1each1-bit和T0for each 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 结尾的字符串并打印结果：

#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
于 2016-08-24T02:46:59.693 回答