using a function to initialise an array variable in C - c

Question

I am a complete beginner.
I have a function which converts an int to an array.
#include <math.h>
#include <stdio.h>
int *convertIntArray(int number) {
int n = log10(number) + 1;
int i;
int *numberArray = calloc(n, sizeof(int));
for (i = 0; i < n; ++i, number /= 10) {
numberArray[i] = number % 10;
}
return numberArray;
}
I'd like to initialise an array named sample in my main function, by passing an integer to the convertIntArray function. My pseudocode looks like:
int main(int argc, char *argv[]) {
int sample = convertIntArray(150);
// rest of main function
But obviously this doesn't work. What is the correct way to do this?

Answer 1

The array is allocated by the converIntArray function and a pointer to its first element is returned. You can store this pointer to array in main if you define array with the appropriate type:
int main(int argc, char *argv[]) {
int *sample = convertIntArray(150);
// rest of main function
Note however that you cannot tell the size of the array pointed to by array from the pointer and the values. You should return either always allocate the maximum size, which is 10 int or return the size some other way, for example as the first element of the array, which you would then allocate with an extra element.

Answer 2

The first thing to note in your code is that you don't include a prototype for function log10() which I guess should be in <math.h>. Or you have done it, but didn't show it in your snippet of code. This is bad posting in StackOverflow, because that leaves us in the dilema of deciding if you made a mistake (by not including it, which will give you undefined behaviour, so, please edit your question, including a minimal, complete and verifiable example.
In case I had to write your function, I should not use log10() because it is a floating point function and you can select the wrong number of digits to allocate in case there's some rounding error in the calculation. Anyway, I'd try to use as less support functions as possible, by changing your interface to this one:
unsigned *number2digits(
unsigned *array_to_work_in, /* the array is provided to the function */
size_t array_size, /* the size of the array, in number of elements */
unsigned source_number, /* the number to be converted */
unsigned base); /* the base to use for conversion */
This approach doesn't force you to include the math library only for the log10() function, and also doesn't make use of the dynamic allocator routines malloc() and calloc(), and the compiler optimises it better if the function doesn't call more external/library functions. In case (see below) you want to use the function on an already allocated array, you don't have to rewrite it. Also, the numbering base is a good thing to pass as parameter, so you are not stuck to base 10 only numbers.
Another error is that you are returning an int * (pointer to int) and you assign the value to a variable of type int (this is a mistake that should have given you a compiler error).
A valid (and complete, and verifiable) example code should be:
#include <stdio.h>
#include <stdlib.h>
unsigned *number2digits(
unsigned *array_to_work_in, /* the array is provided to the function */
size_t array_size, /* the size of the array, in number of elements */
unsigned source_number, /* the number to be converted */
unsigned base) /* the base to use for conversion */
{
size_t i;
for (i = 0; i < array_size; i++) {
array_to_work_in[i] = source_number % base;
source_number /= base;
}
/* if, at this point, source_number != 0, you made an error
* on estimating array size, as the number doesn't fit in
* array_size digits. In case of error, we return NULL to
* indicate the error. */
return source_number == 0 ? array_to_work_in : NULL;
}
#define NUMBER 150000
#define N 10
#define BASE 38
int main()
{
unsigned my_array[N]; /* 10 digits for a base 38 is enough for a 32 bit integer */
unsigned *r = number2digits(my_array, N, NUMBER, BASE);
if (!r) {
fprintf(stderr, "Error, number %u does not fit in %u base %u digits\n",
NUMBER, N, BASE);
exit(EXIT_FAILURE);
}
printf("%u =/base %u/=>", NUMBER, BASE);
int i; /* we use int here as size_t is unsigned and we could
* not detect the loop exit condition */
for (i = N-1; i >= 0; i--) {
printf(" %u", r[i]);
}
printf("\n");
exit(EXIT_SUCCESS);
}
it shows:
$ pru
150000 =/base 38/=> 0 0 0 0 0 0 2 27 33 14
$ _