Returning an Array from a Function in C

Question

I'm just making a mess out of this. I have a function that is supposed to take a one-dimensional array, do some calculations with its values, and then return a similar array with the results of the calculation. I don't necessarily care whether it returns the same array (with new values) or if it creates a new array at a different memory location and returns that. Here is what I've got at the moment. There are errors all over this, but I don't know what I am doing wrong. Can anyone help?

double s  = 10;
double b  = 2.6666;
double r  = 28;

double (*newVertex(double vtx[3] )) [] {

    static double newVtx[3];
    /*  Coordinates  */
    double x = vtx[0];
    double y = vtx[1];
    double z = vtx[2];

    double dt = 0.001;

    double dx = s*(y-x);
    double dy = x*(r-z)-y;
    double dz = x*y - b*z;
    newVtx[0] = x + dt*dx;
    newVtx[1] = y + dt*dy;
    newVtx[2] = z + dt*dz;

    return &newVtx;
}

int main(int argc, char *argv[]) {
    int i;

    /* Arrays to hold the coordinates */
    double thisPt[3] = {1, 1, 1};
    double nextPt[3];

    for (i=0;i<1000;i++) {
        printf("%5d %8.3f %8.3f %8.3f\n", i, thisPt[0], thisPt[1], thisPt[2]);
        nextPt = newVertex(&thisPt);
        thisPt = nextPt;
    }
    return 0;
} 

Answer 1

First of all, your function declaration looks unnecessarily complex to me.

If you're not planning to create a new array, then it should be something like:

void function_name(double *parameter) {
    // code to change the parameter in place here    
}

or, if you want to be explicit about the length of the array (see comments for additional info):

#define ARRAY_SIZE 3
void function_name(double parameter[ARRAY_SIZE]) {
    // code to change the parameter in place here    
}

If you're planning to create a new array, then you could do something like:

double * function_name(double *parameter) {
    double *result = (double *)malloc(sizeof(double * number_of_elements));
    // read parameter, write into result
    return result;
}

The above snippet assumes the number_of_elements is fixed and known. If it is not, then you need to handle them as additional arguments.

Next, this is bad for several reasons:

double (*newVertex(double vtx[3] )) [] {    
    static double newVtx[3];
    // update newVtx    
    return &newVtx;
}

The return statement returns the address of a local variable. In this particular case, the variable is static, so the variable won't be overwritten once the function exits. But does it really need to be static in the first place? And is it sufficient for it to be static? Think about code like this:

double *v1 = newVertex(old_vertex);
double *v2 = newVertex(old_vertex);

You may be tempted to think you can handle the two vertices individually, but they're pointing to the exact same spot in memory: the location of the static variable. It's much more common practice to allocate space for the array dynamically (malloc, calloc) and return a pointer to the allocated memory.

Answer 2

Here nextPt = newVertex(&thisPt);

just pass array name

newVertex(thisPt); //array name thispt==&thispt[0]        
thisPt = nextPt; //illegal and remove this line

Your function

 void newVertex(double *); //declaration

 void newVertex(double *vtx) //defination
 {
 //donot return array 
 } 

print after function call

 newVertex(thisPt); 
 printf("%5d %8.3f %8.3f %8.3f\n", i, thisPt[0], thisPt[1], thisPt[2]);