I am getting the following warning:
expected ‘float **’ but argument is of type ‘float (*)[6]’
Here is my code:
//state and error are output parameters
void func(float* state[6], float* err[6][6]);
int main()
{
float state[6];
float err[6][6];
func(&state, &err);
return 0;
}
I want state and err to be ouptut parameters, so state should be a pointer to an array, and err should be a pointer to a 2 dimensional array.
Change your code to:
void func(float state[], float err[][6]);
int main()
{
float state[6];
float err[6][6];
func(state, err);
return 0;
}
To understand why, you need to know that float* err[6][6] is a 6x6 array of pointers to float, not a pointer to a 6x6 array of floats.
state is effectively equivalent to passing &state[0], the address of the first element in the array. There may be cases where you will want your function to allocate a new array in which case you will have to make your argument a float ** but then there would be no point in creating an array on the stack beforehand.#include <stdio.h>
void func(float (*state)[6], float (*err)[6][6]){
printf("%f, %f\n", (*state)[2], (*err)[1][2]);//3.000000, 3.300000
}
int main()
{
float state[6]={1.0f,2.0f,3.0f};
float err[6][6]={{1.0f,2.0f,3.0f},{1.1f,2.2f,3.3f}};
func(&state, &err);
return 0;
}
In most contexts, an expression of array type will be converted to an expression of pointer type; this means when you pass an array expression to a function as a parameter, what the function will receive is a pointer. The exceptions to this rule are when the array expression is an operand of the sizeof or unary & operators, or is a string literal being used to initialize an array in a declaration.
In the context of a function parameter declaration, T a[] and T a[N] are treated the same as T *a; all three declare a as a pointer to T, not as an array of T.
So, going by your declarations
float state[6];
float err[6][6];
the type of the expression state is "6-element array of float", which in most contexts will be converted to "pointer to float", or float *. Similarly, the type of the expression err is "6-element array of 6-element array of float", which will be converted to "pointer to 6-element array of float", or float (*)[6].
The type of the expression &state is "pointer to 6-element array of float", or float (*)[6], and the type of &err is "pointer to 6-element array of 6-element array of float", or float (*)[6][6].
So, if the call to func is
func(&state, &err);
then the prototype must be
void func(float (*state)[6], float (*err)[6][6])
and you would need to explicitly dereference state and err before applying any subscript:
(*state)[i] = ...;
(*err)[i][j] = ...;
If the call is
func(state, err);
then the prototype must be
void func (float *state, float (*err)[6])
and you would not need to explicitly dereference either state or err:
state[i] = ...;
err[i][j] = ...;
So, which do you use? Personally, I'd go with the second option; it's a little cleaner.
Whereas inside a function, T[][] and T** can be used pretty much interchangeably, when they are being passed as arguments there are caveats. The 'pointer-to-pointer' pattern uses only enough memory to store the variable itself (typically the same as the word size of the processor) and relies on the programmer to somehow generate the correct offsets into the data, whereas with array syntax, the compiler also needs to know the stride of the structure so it can address rows correctly. Personally I don't like passing arrays as parameters for just this reason: it makes the stride fixed at compile time. Better, in my opinion, to always go the T** route with auxiliary parameters for rows and columns.
void func(float* state[6], float* err[6][6]);
int main()
{
float state[6];
float err[6][6];
func(&state, &err);
return 0;
}
Both of the following two declarations are identical...
char *message = "Hello World!";
char message[13] = "Hello World!"; /* "Hello World!" is 12 chars + \0 termination */
Arrays are pointers, just treated differently.
So, to pass the address of message in either of those declarations to func1(char*) OR func1(char[]), you say func1(message); That passes the address.
Arrays can only be passed as addresses to the first value. Run the following program to demonstrate that fact.
#include <stdio.h>
void func(float* array);
int main()
{
float state[6];
int i = 0;
printf ( "Sizeof state: %d\n", sizeof(state) );
for ( i = 0; i < 6; i ++ ) { state[i] = i+1; }
func(state);
return 0;
}
void func ( float *array )
{
printf ( "Sizeof float: %d\n", sizeof(float) );
printf ( "Sizeof array: %d\n", sizeof(array) );
printf ( "Value in array[0] = %f\n", array[0] );
printf ( "Value in *array = %f\n", *array );
array++;
printf ( "Value in array[-1] = %f\n", array[-1] );
printf ( "Value in array[0] = %f\n", array[0] );
printf ( "Value in *array = %f\n", *array );
}
So, your call to func(float* state[6], float* err[6][6] ); is declaring a 2 level pointer, and a 3 level pointer. Similar functionality, but the same call, can be achieved with func(float **state, float ***err );
Needless to say, not what you are aiming for.
