Question

我正在开发一个程序，它从命令行读取两个十进制数字，将它们转换为二进制，添加它们，然后输出二进制和十进制的总和。

我创建了一个将十进制输入转换为二进制的函数，但现在我无法弄清楚如何将这些值转换为int数组。

例如：输入：./a.out 3 2

我的功能将3转换为11，将2转换为10

现在我需要将这些值放在int数组的末尾，所以它看起来像这样：0000000000000000000000000000011和0000000000000000000000000000010

这样我添加二进制数的逻辑可以正常工作。

这是我的尝试，但它说它可以从void分配int：

#include <iostream>
#include <cstdlib>
#include <string.h>

using namespace std;

void binary(int);

int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        cerr << "Invalid number of operands" << endl;
        return 1;
    }
    int i;
    int arg1 = atoi(argv[1]);
    int arg2 = atoi(argv[2]);
    int sum = arg1 + arg2;
    int a[32];
    int b[32];
    int c[32];
    int carry = 0;
    bool print = false;

    for(i = 0; i < 32; i++)
    {
        a[i] = 0;
        b[i] = 0;
        c[i] = 0;
    }
    for(i = 31; i >= 0; i--)
    {
        a[i] = binary(arg1); //PROBLEM AREA
        b[i] = binary(arg2); //PROBLEM AREA
    }
    for(i = 31; i >= 0; i--)
    {
        if (a[i] == 1 && b[i] == 1 && carry == 0)
        {
            c[i] = 0;
            carry = 1;
        }
        else if (a[i] == 1 && b[i] == 0 && carry == 0)
        {
            c[i] = 1;
            carry = 0;
        }
        else if (a[i] == 0 && b[i] == 0 && carry == 0)
        {
            c[i] = 0;
            carry = 0;
        }
        else if (a[i] == 0 && b[i] == 1 && carry == 0)
        {
            c[i] = 1;
            carry = 0;
        }
        else if (a[i] == 1 && b[i] == 1 && carry == 1)
        {
            c[i] = 1;
            carry = 1;
        }
        else if (a[i] == 1 && b[i] == 0 && carry == 1)
        {
            c[i] = 0;
            carry = 1;
        }
        else if (a[i] == 0 && b[i] == 0 && carry == 1)
        {
            c[i] = 1;
            carry = 0;
        }
        else if (a[i] == 0 && b[i] == 1 && carry == 1)
        {
            c[i] = 0;
            carry = 1;
        }
    }
    if(carry == '1')
        cout << carry;
    for (i = 0; i < 32; i++) 
    {
        if (c[i] == 1) 
            print = true;
        if (print) 
            cout << c[i];
    }   
    cout <<  " = " << sum;
    cout << endl;
    return 0;
}

void binary(int number)
{
    int remainder;
    if(number <= 1) 
    {
        cout << number;
        return;
    }
    remainder = number % 2;
    binary(number >> 1);    
    cout << remainder;
}

任何想法或建议都将不胜感激！

Answer 1

由于输入是十进制的，为什么要添加两个二进制表示的小数？将每个数字显示为二进制数但使用十进制值进行加法然后只显示二进制表示的结果会更简单。

编辑：好的，最初没看到你的作业标签。

你的binary（）函数可以返回int的向量，在你的二进制函数中创建向量并返回它。 e.g。

vector<int> binary(int n);

或者在主程序中创建一个数组，将数组传递给二进制函数，然后在返回后打印二进制文件的内容。 e.g。

void binary( int n, int maxSizeArray, int* binArray );

Answer 2

a[i] = binary(arg1); //PROBLEM AREA

方法binary()是 void 方法。您应该从中返回int值，以便将其分配给[i]。

Answer 3

下面：

cout << remainder;

您正在打印剩余部分，而不是将其返回：

return remainder;

不要忘记将void binary(int number)更改为int binary(int number)。

Answer 4

只需使用位操作

#include <iostream>
#include <climits>

template <typename T>
char *to_binary_string(const T &n, char *out) {
   char *p = out;

   if (out) {
      for (int i = sizeof(T) * CHAR_BIT - 1; i >= 0; --i)
         *p++ = ((n & (1 << i)) >> i) + '0';
      *p = 0;
   }

   return out;
}

int main() {
   char buf[33] = "";
   int test[] = { 0xF, 0x2, 0x3, 0xFF, 0x15 };
   for (int i = 0; i < sizeof(test)/sizeof(*test); ++i) {
      std::cout << to_binary_string<int>(test[i], buf) << std::endl;
   }

   return 0;
}

Answer 5

...或者代替那些具有有限位操作符功能的mumbo-jumbo，你可以使用内联汇编功能（我相信这样更有效;没有优化，但是这种方式100％清晰）

void binary(long int var_in, char* var_out)
{
 __asm
 {
  MOV   ESI, var_in
  MOV   EDI, var_out
  ADD   EDI, 0x1F
  XOR   EBX, EBX
  DEC   EBX
  NOT   EBX
@loop1_start:
  NOT   EBX
  INC   EBX
  CMP   EBX, 0x1F
  JG    @loop1_end
  BT    ESI, EBX
  JC    @loop1_set1
  MOV   AL, 0x30
  JMP   @loop1_set0
@loop1_set1:
  MOV   AL, 0x31
@loop1_set0:
  NOT   EBX
  MOV   BYTE PTR DS:[EDI+EBX], AL
  JMP   @loop1_start
@loop1_end:
  MOV   BYTE PTR DS:[EDI+1], 0x00
 }
}

其中 var_in 是32位整数， var_out 是一个至少包含33个元素的字符数组（32个字节+'\ 0'）。

P.S。：您的'二进制'是递归的。因为每个人都知道使用递归函数而不是迭代函数（如果可能的话）会产生更慢的结果。

Answer 6

原因是您正在编写二进制文件以输出，而不是在数组中。你应该做的是，将数组发送到你的函数并填充它。

例如，假设该函数如下所示：

void to_binary(int number, int *array, int position_to_fill);

然后你可以做的就是，就像你写的那样，而不是cout，你在适当的位置写入数组：

void to_binary(int number, int *array, int position_to_fill)
{
    int remainder;
    if (position_to_fill < 0) // shouldn't really happen
        return;
    if (number <= 1)
    {
        array[position_to_fill] = number;
        return;
    }
    remainder = number % 2;
    binary(number >> 1, array, position_to_fill-1);
    array[position_to_fill] = number;
}

这样，您将数组从最后一个位置填充到第一个位置，最后一个位置包含最低位。

现在，当您调用函数时，而不是

for(i = 31; i >= 0; i--)
{
    a[i] = binary(arg1); //PROBLEM AREA
    b[i] = binary(arg2); //PROBLEM AREA
}

你写了

to_binary(arg1, a, 31);
to_binary(arg2, b, 31);

函数输出到int数组

6 个答案: