Function output into int array

The reason is that you are writing the binary to output, rather than in an array. What you should do is, send the array to your function and have it fill it.

For example, let's say the function looks like this:

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

Then what you can do is, exactly like you wrote, but instead of cout, you write to the array in the proper location:

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

This way, you fill the array from last position to the first with the last position containing the least significant bit.

Now, when you call the functions, instead of

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

you write

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

... or instead of that mumbo-jumbo with limited functionality of bit operators you can use inline-assembly function (which is more efficient, I believe; no optimization, but it's 100% clear this way)

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

Where var_in is a 32 bit integer and var_out is a char array of at least 33 elements (32 bytes + '\0').

P.S.: Your 'binary' is recursive. As everybody knows using recursive functions instead of the ones with iteration (if it is possible) produces much slower results.

Just use bit operations

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

Here:

cout << remainder;

you are printing the remainder, instead of returning it:

return remainder;

And don't forget to change void binary(int number) to int binary(int number).

Since the input is decimal, why do you add two binary represented decimals? It would be simpler to just show each number as a binary number but do the addition using decimal values then just show the result in binary representation.

EDIT: ok didnt see your homework tag at first.

your binary() function could return a vector of int, create the vector in your binary function and return it. e.g.

vector<int> binary(int n);

alternatively create an array in your main program, pass the array to the binary function and then print the contents of the binary after it returns. e.g.

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

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

The method binary() is a void method. You should return an int value from it to be able to assign it to a[i].