Parsing and returning array pointers?

I'm trying to write a function that takes as input 3 arrays, does some calculations, puts some values into a global array, then returns a pointer to that array.

function is:

Code:

---

GLfloat calcNormal(GLfloat* B1, GLfloat* B2, GLfloat* T)
{
    //calculations here.
    return normArray[0];
}

---

If I define 3 arrays, A(0,0,0), B(1,0,0), and C(0,1,0), then call printf("%f\n", calcNormal(A[0], B[0], C[0])[2]), compiler says arguments are of wrong type. If I try passing &A[0], &B[0] and &CP[0], compiler says subscripted value is neither array nor pointer.

How should I be passing array pointers to the function?

There's no need to return a pointer to a global array.

Replace the ampersand & with a *, and you'll get a gold star! :)

You can't define arrays like that. You need square brackets for each dimension of the array:

int Array[][][], makes a 3D array of int's.

I do need to return a pointer/array of some sort, due to its actual implementation:

Code:

---

GLfloat normals[8][3] = {calcNormal(B[0], B[1], T[0]), calcNormal(B[1], B[2], T[1]),...}

---

I tried your suggestions, and got 3 errors (one for each argument): invalid type argument of 'unary *' (have 'GLfloat')

I'm not an expert on pointers, but I don't think it's safe to return (and work with), a pointer to a local function's array.

That data might still be good, but it will be overwritten, any old time since the arrays has gone out of scope.

If I were to do this, I'd make the arrays in the calling function, pass them to the other functions as needed, and then there would be no trouble using the array's data.

normArrays is a global array, not local.
Probably worth clarifying that I don't want the contents of normals to point to normArray, but to be set to the values of normArray (set by the call to calcNormal).

Well, it's no problem returning a pointer to an array. A pointer to an array is just another type of pointer, so that's no problem. If the array is going to be destroyed as a local variable, then you're playing with fire to use that returned pointer.

I'm no expert on pointers, however. Let me back out of here, and perhaps one of them will give you a more cogent reply.

Quote:

---

Originally Posted by Adak

I'm not an expert on pointers, but I don't think it's safe to return (and work with), a pointer to a local function's array.

---

No, it's not, since pointers are just variables with addresses. They don't change scope rules or anything like that.
Once the array goes out of scope, it's destroyed and the pointer will be dangling.

Elysia, do you have any help for me?

How does the call to calcNormal look like?
Further, why are you assigning to a global variable and then returning it?

Post #3 answers your first question.

To answer your second question, I obviously can't use a local array, as the array would be lost when calcNormal ends. This is not the issue at all though.

Quote:

---

Originally Posted by thealmightyone

Post #3 answers your first question.

---

Of course. Silly of me.
But what I needed to ask was how the arrays you pass are declared?

Quote:

---

To answer your second question, I obviously can't use a local array, as the array would be lost when calcNormal ends. This is not the issue at all though.

---

You can make a local array and pass a pointer to it to the calcNormal function.

The arrays B and T are of the form:

Code:

---

T[8][3] = { {9.0, 4.6, -1.0}, etc}
B[8][3] = { {4.5, 1.0, -10.0}, etc}

---

If I decide to improve the code, I will localise stuff. For now, I just want to get my head around using array pointers.

Are they of type GLfloat? If yes, then the code should work... Unless you have mixed and twisted it a little...

The code does compile if I don't include the line in post #1 (which is not needed for program), but I'm pretty sure there's still a problem.

When array 'normals' tries to set itself to the values in normArray, blending does not work (which requires the arrays in 'normals'). If I replace one of the calls with actual numbers (calculated by hand), blending works for that normal. I have no ides what calcNormal is putting into normals, but it's not working as it should.

Hopefully, that makes sense.

This works and compiles (although is warns about truncation from double to float):

Code:

---

typedef float GLfloat;

GLfloat calcNormal(GLfloat* B1, GLfloat* B2, GLfloat* T)
{
    //calculations here.
    //return normArray[0];
        return 0.0f;
}

int main()
{
        float T[2][3] = { {9.0, 4.6, -1.0}, { 0.0f, 0.0f, 0.0f } };
        float B[2][3] = { {4.5, 1.0, -10.0}, { 0.0f, 0.0f, 0.0f } };
        calcNormal(T[0], T[1], B[0]);
        return 0;
}

---

This is kinda embrassing.

Printed out first member of normals, and it's fine. The problem seems to be with the calcNormal function, as the values aren't quite correct. Somehow got it into my head that calcNormal couldn't possible be wrong.

I have done some more playing around, and the problem is actually still here, and the problem is when transferring the contents of normArray to normals.

I had to make 'normals 2d', as if it is just 1d (without {0,0,0}), it will not compile at all.

Both printf's should print out 0,0,-1, but they differ. So, back to square one; why is 'normals' not settings its contents to what is returned by calcNormal?

Code:

---



float normArray[3];  // If declared in main, doesn't compile. This is the least of my worries at the moment.

int main(void)
{
    GLfloat points[4][3] = { {0,0,0}, {0,1,0}, {1,1,0}, {1,0,0} };
    GLfloat normals[2][3] = {{calcNormal(points[0], points[1], points[3])}, {0, 0, 0}};
    printf("actual normal is %f, %f, %f\n", normals[0][0], normals[0][1], normals[0][2]);

    return 0;
}

GLfloat calcNormal(GLfloat* B1, GLfloat* B2, GLfloat* T)
{
    GLfloat A[3] = {B2[0] - B1[0], B2[1] - B1[1], B2[2] - B1[2]};
    GLfloat B[3] = {T[0] - B1[0], T[1] - B1[1], T[2] - B1[2]};

    normArray[0] = (A[1]*B[2]) - (A[2]*B[1]);
    normArray[1] = (A[2]*B[0]) - (A[0]*B[2]);
    normArray[2] = (A[0]*B[1]) - (A[1]*B[0]);

    printf("normal is %f, %f, %f\n", normArray[0], normArray[1], normArray[2]);

    return normArray[0];
}

---

Shouldn't point[0], point[1], etc., have a second dimension?

It is a 2D array.

It does have a second dimension. Point[0] is (0,0,0)

Quote:

---

Originally Posted by thealmightyone

It does have a second dimension. Point[0] is (0,0,0)

---

I was thinking you were going to say that. Doesn't that mean you're trying to put 9 numbers total, into the 0th row of the receiving array?

Then the second row, just gets three 0's, so it's okay.

That question confuses me, so will answer best I can. I am passing 3 arrays, of size 3, into calcNormal. calcNormal is recieving the arrays correctly, as it is correctly calculating values. I have verified this with different input arrays.

The issue is in passing the values in normArray, AFTER the calculations, into normals, via a pointer.

EDIT: Remember, normArray is a 1d array, not 2d, of size 3.

My compiler immediately gives the error:
"Illegal initialization", on that line.

I'm suggesting the normals array, is not getting the values you want it to have. You have 9 ints, trying to be initialized into one row which holds only 3 ints.

points[0] = 3 int's
points[1] = 3 int's
points[3] = 3 ints

All for the 0th row of the normals array, which holds 3 ints, only.

Oh, you think calcNormals returns an array of size 9?

Arrays point[0], [1] and [2] are fed INTO calcNormal (called by normals[x]), which returns pointer to normArray (size 3), which normals[x] is meant to set itself to.

No, I've been helping beginners too much.

normArray[0] is one number, however.

It's not a pointer to three numbers.

Well spotted. Not fixed the code, but 1 step there. Should be &normArray[0], and function should be defined to return float*. I still can't get it to compile though, am getting 'excess elements in scalar initializer' errors.

I made my numbArray global, as per your suggestion, and changed the return from calcNormal to void.

No joy. The compiler won't have anything to do with initializations that involve a row of digits, being subtracted by another row of digits, and the result of that, going into one element of the array being initialized.

My suggestion would be to initialize the arrays, then do the subtraction in for loops, and get those answers into variables, and then assign them to the array either with more for loops or explicit assignments.

I used that to get main() to compile, like this:

Code:

---

#include <stdio.h>

float normArray[3];

void calcNormal(float* B1, float* B2, float* T);

int main(void)
{
  int i;
    float points[4][3] = { {0,0,0}, {0,1,0}, {1,1,0}, {1,0,0} };
    float normals[2][3];

    calcNormal(points[0], points[1], points[3]);

    for(i = 0; i < 3; i++) {
      normals[0][i] = normArray[i];
      normals[1][i] = 0;
    }
    normals[0][2] = normArray[3];
    printf("actual normal is %f, %f, %f\n", normals[0][0], normals[0][1], normals[0][2]);


    i = getchar();
    return 0;
}

---

I'm not confident that code is correct, because I couldn't actually test it, but it does compile. That's how I'd work with the calcNormal() function.

Your way would be a great time saver, I couldn't grok the concept of it at first. :)

Yeah, I began coming to the realisation that what I wanted to isn't actually possible (I'm always looking for small and elegant solutions). Got it all working with some for loops now.