函數輸出到int數組

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向量，在您的二進制函數中創建該向量並將其返回。 例如

vector<int> binary(int n);

或者在您的主​​程序中創建一個數組，將該數組傳遞給二進制函數，然后在二進制返回后打印其內容。 例如

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

Answer 2

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

該方法binary()是一個無效方法。 您應該從中返回一個int值，以便將其分配給a [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'）的char數組。

PS：您的“ 二進制 ”是遞歸的。 眾所周知，使用遞歸函數而不是使用迭代函數（如果可能的話）會產生慢得多的結果。

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