Writing an array of integers into a file using C [duplicate]

First, be aware that there are two interpretations for 'binary':

int n = 1012;
fwrite(&n, sizeof(n), 1, file);

This writes out the data just as is; as it is represented in form of bits, output is considered "binary" (a binary file).

Your question and the code you provided, though, rather imply that you actually want to have a file containing the numbers in binary text format, i. e. 7 being represented by string "111".

Then first, be aware that 0 and 1 do not represent the characters '0' and '1' in most, if not all, encodings. Assuming ASCII or compatible, '0' is represented by value 48, '1' by value 49. As C standard requires digits [0..9] being consecutive characters (this does not apply for any other characters!), you can safely do:

binaryNum[i] = '0' + n % 2;

Be aware that, as you want strings, you chose the bad data type, you need a character array:

static char binaryNum[X];

X??? We need to talk about required size!

If we create strings, we need to null-terminate them. So we need place for the terminating 0-character (really value 0, not 48 for character '0'), so we need at least one character more.

Currently, due to the comparison n > 0, you consider negative values as equal to 0. Do you really intend this? If so, you might consider unsigned int as data type, otherwise, leave some comment, then I'll cover handling negative values later on.

With restriction to positive values, 16 + 1 as size is fine, assuming int has 32 bit on your system! However, C standard allows int to be smaller or larger as well. If you want to be portable, use CHAR_BIT * sizeof(int) / 2 (CHAR_BIT is defined in <limits.h>; drop division by 2 if you switch to unsigned int).

There is one special case not covered: integer value 0 won't enter the loop at all, thus you'd end up with an empty string, so catch this case separately:

if(n == 0)
{
    binaryNum[i++] = '0';
}
else
{
    while (n > 0) { /.../ }
}
// now the important part:
// terminate the string!
binaryNum[i] = 0;

Now you can simply do (assuming you changed p to char*):

written = fprintf(file, "%s\n", p);
//                         ^^ only if you want to have each number on separate line
//                          you can replace with space or drop it entirely, if desired

Be aware that the algorithm, as is, prints out least significant bits first! You might want to have it inverse, then you'd either yet have to revert the string or (which I would prefer) start with writing the terminating 0 to the end and then fill up the digits one by one towards front - returning a pointer to the last digit (the most significant one) written instead of always the start of the buffer.

One word about your original version:

written = fwrite(p, sizeof(int), sizeof(p), infile);

sizeof(p) gives you the size of a pointer; this one is system dependent, but will always be the same on the same system, most likely 8 on yours (if modern 64-bit hardware), possibly 4 (on typical 32-bit CPU), other values on less common systems are possible as well. You'd need to return the number of characters printed separately (and no, sizeof(binaryNum) won't be suitable as it always returns 17, assuming 32-bit int and all changes shown above applied).

You probably want this:

...
int main()
{
  int decimal = 2000;    
  int *p = decToBinary(decimal);

  for (int i = 0; i< 16; i++)
  {
    printf("%d", p[i]);
  }

  return 0;
}

The output goes to the terminal instead into a file.

For writing into a file use fopen as in your code, and use fprintf instead of printf.

Concerning the decToBinary there is still room for improvement, especially you could transform the number directly into an array of char containing only chars 0 and 1 using the << and & operators.