如何从C中的函数返回多个类型？

Question

I have a function in C which calculates the mean of an array. Within the same loop, I am creating an array of t values. My current function returns the mean value. How can I modify this to return the t array also?

/* function returning the mean of an array */
double getMean(int arr[], int size) {
   int i;
   printf("\n");
   float mean;
   double sum = 0;
   float t[size];/* this is static allocation */
    for (i = 0; i < size; ++i) {
        sum += arr[i];
        t[i] = 10.5*(i) / (128.0 - 1.0);
        //printf("%f\n",t[i]);
   }
   mean = sum/size;
   return mean;
}

Thoughts: Do I need to define a struct within the function? Does this work for type scalar and type array? Is there a cleaner way of doing this?

Answer 1

You can return only 1 object in a C function. So, if you can't choose, you'll have to make a structure to return your 2 values, something like :

typedef struct X{
     double mean;
     double *newArray;
} X;

BUT, in your case, you'll also need to dynamically allocate the t by using malloc otherwise, the returned array will be lost in stack.

Another way, would be to let the caller allocate the new array, and pass it to you as a pointer, this way, you will still return only the mean, and fill the given array with your computed values.

Answer 2

The most common approach for something like this is letting the caller provide storage for the values you want to return. You could just make t another parameter to your function for that:

double getMean(double *t, const int *arr, size_t size) {
   double sum = 0;
   for (size_t i = 0; i < size; ++i) {
        sum += arr[i];
        t[i] = 10.5*(i) / (128.0 - 1.0);
   }
   return sum/size;
}

This snippet also improves on some other aspects:

• Don't use float , especially not when you intend to return a double . float has very poor precision
• Use size_t for object sizes. While int often works, size_t is guaranteed to hold any possible object size and is the safe choice
• Don't mix output in functions calculating something (just a stylistic advice)
• Declare variables close to where they are used first (another stylistic advice)
• This is somewhat opinionated, but I changed your signature to make it explicit the function is passed pointers to arrays, not arrays. It's impossible to pass an array in C, therefore a parameter with an array type is automatically adjusted to the corresponding pointer type anyways.
• As you don't intend to modify what arr points to, make it explicit by adding a const . This helps for example the compiler to catch errors if you accidentally attempt to modify this array.

You would call this code eg like this:

int numbers[] = {1, 2, 3, 4, 5};
double foo[5];

double mean = getMean(foo, numbers, 5);

instead of the magic number 5 , you could write eg sizeof numbers / sizeof *numbers .

---

Another approach is to dynamically allocate the array with malloc() inside your function, but this requires the caller to free() it later. Which approach is more suitable depends on the rest of your program.

Answer 3

Following the advice suggested by @FelixPalmen is probably the best choice. But, if there is a maximum array size that can be expected, it is also possible to wrap arrays in a struct , without needing dynamic allocation. This allows code to create new struct s without the need for deallocation.

A mean_array structure can be created in the get_mean() function, assigned the correct values, and returned to the calling function. The calling function only needs to provide a mean_array structure to receive the returned value.

#include <stdio.h>
#include <assert.h>

#define MAX_ARR  100

struct mean_array {
    double mean;
    double array[MAX_ARR];
    size_t num_elems;
};

struct mean_array get_mean(int arr[], size_t arr_sz);

int main(void)
{
    int my_arr[] = { 1, 2, 3, 4, 5 };

    struct mean_array result = get_mean(my_arr, sizeof my_arr / sizeof *my_arr);

    printf("mean: %f\n", result.mean);
    for (size_t i = 0; i < result.num_elems; i++) {
        printf("%8.5f", result.array[i]);
    }
    putchar('\n');

    return 0;
}

struct mean_array get_mean(int arr[], size_t arr_sz)
{
    assert(arr_sz <= MAX_ARR);
    struct mean_array res = { .num_elems = arr_sz };
    double sum = 0;

    for (size_t i = 0; i < arr_sz; i++) {
        sum += arr[i];
        res.array[i] = 10.5 * i / (128.0 - 1.0);
    }
    res.mean = sum / arr_sz;

    return res;
}

Program output:

mean: 3.000000
0.00000 0.08268 0.16535 0.24803 0.33071

In answer to a couple of questions asked by OP in the comments:

size_t is the correct type to use for array indices, since it is guaranteed to be able to hold any array index. You can often get away with int instead; be careful with this, though, since accessing, or even forming a pointer to, the location one before the first element of an array leads to undefined behavior. In general, array indices should be non-negative. Further, size_t may be a wider type than int in some implementations; size_t is guaranteed to hold any array index, but there is no such guarantee for int .

Concerning the for loop syntax used here, eg, for (size_t i = 0; i < sz; i++) {} : here i is declared with loop scope . That is, the lifetime of i ends when the loop body is exited. This has been possible since C99. It is good practice to limit variable scopes when possible. I default to this so that I must actively choose to make loop variables available outside of loop bodies.

If the loop-scoped variables or size_t types are causing compilation errors, I suspect that you may be compiling in C89 mode. Both of these features were introduced in C99.If you are using gcc, older versions (for example, gcc 4.x, I believe) default to C89. You can compile with gcc -std=c99 or gcc -std=c11 to use a more recent language standard. I would recommend at least enabling warnings with: gcc -std=c99 -Wall -Wextra to catch many problems at compilation time. If you are working in Windows, you may also have similar difficulties. As I understand it, MSVC is C89 compliant, but has limited support for later C language standards.