如何在C中返回三个3d数组？

Question

I'm trying to write a C function to perform some vector calculations and generate three separate 3d arrays . I allocate the arrays at the beginning of the function

double fac_x[Ny][Nx][Nz];
double fac_y[Ny][Nx][Nz];
double fac_z[Ny][Nx][Nz];

then fill them in with calculated values.

How can I return all three of these arrays? What does the function prototype need to look like?

Answer 1

There is a couple of options :

• Create a struct to hold those arrays and return it

• Pass pointers to those arrays and modify them without returning anything

• (Not elegant) Return array of those arrays

• (Not elegant) Make some global variables and modify them

Answer 2

There are two ways you can follow to return your arrays.

1. Make a Structure with your three arrays and return the structure
2. Pass the reference to the three arrays in the function.

Answer 3

You can't return more than one value at a time in C, so your choices are:
1) Access them globally.
2) Send references (pointers) into the function.
3) Make all three of them into one struct and return that.

Answer 4

Do yourself a favour, and implement 3D arrays as

  double *fac_x = malloc(Nx * Ny * Nz * sizeof(double));

  fac_x[z*Ny*Nx + y * Nx + x] = 123.0;

Now all the syntactical complications fall away. You still need to return three double *s, which entails taking double **s as parameters. That's tolerable. double **** parameters are not.

Answer 5

Returning a non static array (1D, 2D or 3D) from a function results in troubles because those arrays haves local scope, you can use dynamic memory, in this case a pointer to a 3D array:

#include <stdio.h>
#include <stdlib.h>

void *func(void)
{
    double (*ptr)[3][4][5] = calloc(3, sizeof *ptr);

    if (ptr == NULL) {
        perror("malloc");
        exit(EXIT_FAILURE);
    }
    ptr[0][0][0][0] = 1.1;
    ptr[1][1][1][1] = 2.2;
    ptr[2][2][2][2] = 3.3;
    return ptr;
}

int main(void)
{
    double (*ptr)[3][4][5] = func();

    printf("%f\n", ptr[0][0][0][0]);
    printf("%f\n", ptr[1][1][1][1]);
    printf("%f\n", ptr[2][2][2][2]);
    free(ptr);
    return 0;
}

Answer 6

The only way to actually return an array is to return a structure or union type with that array as a member. This involves copying the array contents, which could present an efficiency problem. More importantly, however, this is viable only if the array dimensions (your Nx , Ny , and Nz ) are compile-time constants. Example:

#define Nx 5
#define Ny 7
#define Nz 10

struct arrays {
    double fac_x[Ny][Nx][Nz];
    double fac_y[Ny][Nx][Nz];
    double fac_z[Ny][Nx][Nz];
};

struct arrays foo() {
    struct arrays rval;

    // ... fill in the elements of rval ...

    return rval;
}

Otherwise, you cannot return arrays at all. You could return a struct or array of pointers to the arrays or to their first elements (provided again that at least the last two dimensions are compile-time constants), but although that might serve your purpose, it is not the same thing.

More importantly, the arrays you are declaring in your function have lifetime limited to the scope in which they are declared. Although you can obtain and even return a pointers to or into them, such pointers will be invalid after the function returns.

If you want to allocate space inside your function whose lifetime extends past the function's return, you need dynamic allocation via malloc() or calloc() . Supposing that you want to give the caller access to the allocated space, I recommend using output parameters (pointers) to convey the information back. Example:

int foo(unsigned Nx, unsigned Ny, unsigned Nz, double(*fac_x)[Nx][Nz],
        double(*fac_y)[Nx][Nz], double(*fac_z)[Nx][Nz]) {
    double (*tx)[Nx][Nz] = malloc(Ny * sizeof(*tx));

    if (!tx) {
        return -1;
    }

    double (*ty)[Nx][Nz] = malloc(Ny * sizeof(*ty));

    if (!ty) {
        free(tx);
        return -1;
    }

    double (*tz)[Nx][Nz] = malloc(Ny * sizeof(*tz));

    if (!tz) {
        free(tx);
        free(ty);
        return -1;
    }

    // ... fill tx, ty, and tz ...

    // supposing no errors have occurred:
    fac_x = tx;
    fac_y = ty;
    fac_z = tz;
    return 0;
}

This would be called like so:

int caller(unsigned Nx, unsigned Ny, unsigned Nz) {
    if (Nx == 0 || Ny == 0 || Nz == 0) {
        // error: invalid dimensions
        return -1;
    }

    // Note: these are pointers to arrays, not arrays themselves.
    double (*fac_x)[Nx][Nz];
    double (*fac_y)[Nx][Nz];
    double (*fac_z)[Nx][Nz];

    if (foo(Nx, Ny, Nz, fac_x, fac_y, fac_z)) {
        // handle error ...
    }

    // We are now responsible for freeing fac_x, fac_y, and fac_z

    // do stuff ... with fac_x[p][q][r], etc. ...
}

Answer 7

There could be multiple solutions:

USING 4D-ARRAY RETURN

double**** getArrays();

USING 4D-ARRAY OUTPUT PARAMETERS:

Signature:

void getArrays(double****, double****, double****)

Calling:

double*** array1 = NULL;
double*** array2 = NULL;
double*** array3 = NULL;
void getArrays(&array1, &array2, &array3)

USING Structure:

typedef struct{
  double*** array1;
  double*** array2;
  double*** array3;
} MyStruct;

MyStruct getArrays(); //prototype 1
void getArrays(MyStruct*) //prototype 2

USING 2D VOID POINTER OUTPUT PARAMETERS: (if passing 4D parameters is not convenient)

Signature:

void getArrays(void**, void**, void**)

Calling:

void* array1 = NULL;
void* array2 = NULL;
void* array3 = NULL;
void getArrays(&array1, &array2, &array3)
double*** ar1 = (double***)array1;
...