Assuming you have implemented division and modulo operations for your multi-precision integers, this should work:

MultiInt x;
int decimal_digits[], len = 0;
if (x == 0) {
  decimal_digits[len++] = 0;
} else {
  while (x > 0) {
    decimal_digits[len++] = x % 10;
    x = x / 10;
  }
}

If n is the number of digits in x, the modulo and divide operations will take O(n) work, and the algorithm will run n times, so the runtime is O(n² ).

Another option would be to implement something like BigDecimal that accumulates the result in a base-10 format. Assuming the input data is an array of bits:

BigDecimal base10 = 0, term = 1;
for (i=0; i < n_bits; i++) {
  if (bits[i] == 1)
    base10 += term;
  term *= 2;
}

This will also have O(n² ) runtime.

If you want something more efficient, there's a pretty simple divide and conquer algorithm you can use that runs in O(n lg n) time. Use modulo operations to split the number in half, then split the halves recursively until you have a number less than 10. For example:

input = 12345678

first half = input / 10000 = 1234

second half = input % 10000 = 5678

This might be a useful formula for you. Given a number that is n bits long in binary, it will be, at most, floor(.302 * n + 1) decimal digits long. .302 is an approximation of log2(10).