>    void (*fnc)(double M[][]) = getMatrix;

>    (*fnc)( A );

>    printf("[ %.1f, %.1f]\n", A[0][0], A[0][1]);
>    printf("[ %.1f, %.1f]\n", A[0][2], A[1][0]);

>    return 0;}

> I've a couple of (automatically) created functions that take
> 2-dimensional array as inputs, like

> void getMatrix( double M[2][2] )
> {
>   M[0][0] = 1;
>   M[0][1] = 0;
>   M[1][0] = 0;
>   M[1][1] = 1;  
> }

> The size of the matrices varies: 2x2, 3x2, etc. but is always defined in
> the function header.

> void getMatrix( double M[2][2] );

> void getMatrix( double M[2][2] )
> {
>   M[0][0] = 1;
>   M[0][1] = 0;
>   M[1][0] = 0;
>   M[1][1] = 1;  
> };

>   void (*fnc)(double M[][]) = getMatrix;

>   return 0;
> }
> ============================================================
> Although the compiler takes it and the executable prints the desired
> result, it seems a bit odd to me.

>>    void (*fnc)(double M[][]) = getMatrix;

>>    (*fnc)( A );

>>    printf("[ %.1f, %.1f]\n", A[0][0], A[0][1]);
>>    printf("[ %.1f, %.1f]\n", A[0][2], A[1][0]);

>>    return 0;}

> Probably the easier way to do this sort of anonymous thing is use a 1D
> array then access it via macro

> #define M(i, j) R[i*width+j]

> Where "width" is a constant that the compiler can optimize [e.g. *4 ==
> <<2 and so on, or more importantly just access the array with known
> offsets if it unrolls your code or whatever].

> The only other way I can think of doing this is with structs, e.g.

> struct twobytwo { double M[2][2]; }

> then you pass

> void func(struct twobytwo *M);

> Then you can have anonymous matrix functions that take (void *) and
> they internally cast it to a pointer of the right struct.  I can't
> think of how you'd declare "a pointer to an array of 2 of array of 2
> doubles" ...

> Tom

>> void getMatrix( double M[2][2] )
>> {
>>   M[0][0] = 1;
>>   M[0][1] = 0;
>>   M[1][0] = 0;
>>   M[1][1] = 1;   }

>> The size of the matrices varies: 2x2, 3x2, etc. but is always defined
>> in the function header.

>     Well, sort of.  The first [2] is just decoration, the second [2]
> actually matters.  After "decay," the parameter of getMatrix() is
> a pointer, whose target type is array-of-two-double.

>> I don't need all matrices simultaneously. Is it allowed to pass an
>> array that has larger dimensions (i.e. those of the largest matrix)
>> than specified in the function header? Currently I tried this:
>> ============================================================
>> #include <stdio.h>

>> void getMatrix( double M[2][2] );

>> void getMatrix( double M[2][2] )
>> {
>>   M[0][0] = 1;
>>   M[0][1] = 0;
>>   M[1][0] = 0;
>>   M[1][1] = 1;   };

>     Stray semicolon.

>> int main( void )
>> {
>>   double A[3][3];

>>   void (*fnc)(double M[][]) = getMatrix;

>     No good, because you get only one level of "decay."  This line
> tries to declare fnc as a pointer to a function whose parameter is
> a pointer to an array of unknown size -- not a pointer to the first
> element of such an array, but a pointer to the entire array.  Since
> the array's size is unknown, it's an "incomplete type."

>     The parameter of getMatrix() is not a pointer to an array of an
> unknown number of double elements, but a pointer to an array of two
> double elements.  Thus, the type of getMatrix() disagrees with the
> type of function fcn is supposed to point at.  You ought to get a
> diagnostic here.

>>   (*fnc)( A );

>     ... but if the code compiled anyhow, this is undefined behavior.
> You're calling a function of one type through a pointer to functions
> of a different type, and that's a no-no.

>     C's handling of multi-dimensional arrays is a bit clumsy, and can
> make trouble in situations like yours.  The comp.lang.c Frequently
> Asked Questions (FAQ) list at <http://www.c-faq.com/> may prove useful,
> particularly Questions 6.19 and 6.21 -- it's probably worth your while
> to look at all of Section 6.

> void getMatrix( double M[2][2] )
> {
>   M[0][0] = 1;
>   M[0][1] = 0;
>   M[1][0] = 0;
>   M[1][1] = 1;    
> }

>>I've a couple of (automatically) created functions that take
>>2-dimensional array as inputs, like

>>void getMatrix( double M[2][2] )
>>{
>>  M[0][0] = 1;
>>  M[0][1] = 0;
>>  M[1][0] = 0;
>>  M[1][1] = 1;  
>>}

> [snip]

> No, you don't have a function with a 2-dimensional array as a
> parameter, because there's no such thing in C as an array parameter.

> Yes, you have something that *looks* like an array parameter,
> but it really isn't.  The parameter declaration
>     double M[2][2]
> is quietly translated to
>     double (*M)[2]
> i.e., M is really a pointer to an array of 2 doubles.  Typically, it
> will point to the first element of an array of arrays of 2 doubles.
> The second "2" in the parameter declaration is silently ignored.

>>>void getMatrix( double M[2][2] )
[...]

>> No, you don't have a function with a 2-dimensional array as a
>> parameter, because there's no such thing in C as an array parameter.

>> Yes, you have something that *looks* like an array parameter,
>> but it really isn't.  The parameter declaration
>>     double M[2][2]
>> is quietly translated to
>>     double (*M)[2]
>> i.e., M is really a pointer to an array of 2 doubles.  Typically, it
>> will point to the first element of an array of arrays of 2 doubles.
>> The second "2" in the parameter declaration is silently ignored.

>  The *first* "2" in the parameter declaration is silently ignored.

> /* BEGIN this.c */

> void func(double M[1][2]);
> void func(double M[2][2]);
> void func(double (*M)[2]);

> /* END this.c */

>>>    void (*fnc)(double M[][]) = getMatrix;

>>>    (*fnc)( A );

>>>    printf("[ %.1f, %.1f]\n", A[0][0], A[0][1]);
>>>    printf("[ %.1f, %.1f]\n", A[0][2], A[1][0]);

>>>    return 0;}

>> Probably the easier way to do this sort of anonymous thing is use a 1D
>> array then access it via macro

>> #define M(i, j) R[i*width+j]

>> Where "width" is a constant that the compiler can optimize [e.g. *4 ==
>> <<2 and so on, or more importantly just access the array with known
>> offsets if it unrolls your code or whatever].

> Thanks for your fast reply. If I got it right, you suggest to avoid
> the use of a 2D array and stick to 1d one. Properly I missed your
> point how to implement it, but does it require a change in getMatrix?

> I didn't mentioned it clearly in the first posting: the "getMatrix"
> function is generated "somewhere else". Thus, I have no control
> there. I could post process the function and try to change the
> definitions, but i would prefer to leave these functions untouched.

>> Tom St Denis wrote:
>>>> int main( void )
>>>> {
>>>>    double A[3][3];

>>>>    void (*fnc)(double M[][]) = getMatrix;

>>>>    (*fnc)( A );

>>>>    printf("[ %.1f, %.1f]\n", A[0][0], A[0][1]);
>>>>    printf("[ %.1f, %.1f]\n", A[0][2], A[1][0]);

>>>>    return 0;}
>>> Probably the easier way to do this sort of anonymous thing is use a 1D
>>> array then access it via macro

>>> #define M(i, j) R[i*width+j]

>>> Where "width" is a constant that the compiler can optimize [e.g. *4 ==
>>> <<2 and so on, or more importantly just access the array with known
>>> offsets if it unrolls your code or whatever].
>> Thanks for your fast reply. If I got it right, you suggest to avoid
>> the use of a 2D array and stick to 1d one. Properly I missed your
>> point how to implement it, but does it require a change in getMatrix?

>> I didn't mentioned it clearly in the first posting: the "getMatrix"
>> function is generated "somewhere else". Thus, I have no control
>> there. I could post process the function and try to change the
>> definitions, but i would prefer to leave these functions untouched.

> Can you change the type?  If so there is another way: and array of
> pointers -- each one points to the start of a 1D array.  Access looks
> exactly the same so the body of the getMatrix code is the same.

> The advantage is that you can access the 2x2 part of, say, a 3x3
> matrix seamlessly this way (which, unless I've misread the situation
> is you problem).  The down side is that it is more complex to allocate
> and free such things.

> Forgive me for not saying more now, but since it may not be a solution
> it seems a waste of time to explain it in detail.

>>>> void getMatrix( double M[2][2] )
> [...]
>>> No, you don't have a function with a 2-dimensional array as a
>>> parameter, because there's no such thing in C as an array parameter.

>>> Yes, you have something that *looks* like an array parameter,
>>> but it really isn't.  The parameter declaration
>>>     double M[2][2]
>>> is quietly translated to
>>>     double (*M)[2]
>>> i.e., M is really a pointer to an array of 2 doubles.  Typically, it
>>> will point to the first element of an array of arrays of 2 doubles.
>>> The second "2" in the parameter declaration is silently ignored.
>>  The *first* "2" in the parameter declaration is silently ignored.

> Quite right.

>> this compiles without warnings:

>> /* BEGIN this.c */

>> void func(double M[1][2]);
>> void func(double M[2][2]);
>> void func(double (*M)[2]);

>> /* END this.c */

> Yup.

> Here's how I convinced myself you're right:

> % cdecl
> Type `help' or `?' for help
> cdecl> declare M as array 10 of array 20 of double
> double M[10][20]
> cdecl> declare M as pointer to array 20 of double
> double (*M)[20]
> cdecl>
> %

>> pete <pfil...@mindspring.com> writes:

>>> Keith Thompson wrote:

>>>> Michael <michaelk...@googlemail.com> writes:

>>>>> I've a couple of (automatically) created functions that take
>>>>> 2-dimensional array as inputs, like

>>>>> void getMatrix( double M[2][2] )

>> [...]

>>>> No, you don't have a function with a 2-dimensional array as a
>>>> parameter, because there's no such thing in C as an array parameter.

>>>> Yes, you have something that *looks* like an array parameter,
>>>> but it really isn't.  The parameter declaration
>>>>     double M[2][2]
>>>> is quietly translated to
>>>>     double (*M)[2]
>>>> i.e., M is really a pointer to an array of 2 doubles.  Typically, it
>>>> will point to the first element of an array of arrays of 2 doubles.
>>>> The second "2" in the parameter declaration is silently ignored.

>>>  The *first* "2" in the parameter declaration is silently ignored.

>> Quite right.

>>> this compiles without warnings:

>>> /* BEGIN this.c */

>>> void func(double M[1][2]);
>>> void func(double M[2][2]);
>>> void func(double (*M)[2]);

>>> /* END this.c */

>> Yup.

>> Here's how I convinced myself you're right:

>> % cdecl
>> Type `help' or `?' for help
>> cdecl> declare M as array 10 of array 20 of double
>> double M[10][20]
>> cdecl> declare M as pointer to array 20 of double
>> double (*M)[20]
>> cdecl>
>> %

> Thanks to you two for clarifying that.

>>> Tom St Denis wrote:
>>>>> int main( void )
>>>>> {
>>>>>    double A[3][3];

>>>>>    void (*fnc)(double M[][]) = getMatrix;

>>>>>    (*fnc)( A );

>>>>>    printf("[ %.1f, %.1f]\n", A[0][0], A[0][1]);
>>>>>    printf("[ %.1f, %.1f]\n", A[0][2], A[1][0]);

>>>>>    return 0;}
>>>> Probably the easier way to do this sort of anonymous thing is use a 1D
>>>> array then access it via macro

>>>> #define M(i, j) R[i*width+j]

>>>> Where "width" is a constant that the compiler can optimize [e.g. *4 ==
>>>> <<2 and so on, or more importantly just access the array with known
>>>> offsets if it unrolls your code or whatever].
>>> Thanks for your fast reply. If I got it right, you suggest to avoid
>>> the use of a 2D array and stick to 1d one. Properly I missed your
>>> point how to implement it, but does it require a change in getMatrix?

>>> I didn't mentioned it clearly in the first posting: the "getMatrix"
>>> function is generated "somewhere else". Thus, I have no control
>>> there. I could post process the function and try to change the
>>> definitions, but i would prefer to leave these functions untouched.

>> Can you change the type?  If so there is another way: and array of
>> pointers -- each one points to the start of a 1D array.  Access looks
>> exactly the same so the body of the getMatrix code is the same.

>> The advantage is that you can access the 2x2 part of, say, a 3x3
>> matrix seamlessly this way (which, unless I've misread the situation
>> is you problem).  The down side is that it is more complex to allocate
>> and free such things.

> Hi, well that sounds good to me. I cannot change the the type during
> the "creation" of the function, but it looks to me that I can do the
> change afterwards automatically.

>   for( nI=0; nI<3; nI++)
>     A[nI] = malloc( 3*sizeof(*A[nI]));

>       printf("[ %.1f, %.1f]\n", A[0][0], A[0][1]);
>       printf("[ %.1f, %.1f]\n", A[1][0], A[1][1]);
>     }

>   for( nI=0; nI<3; nI++)
>     free(A[nI]);

>   return 0;
> }
> =============================================================
> Well, then also Q.6.19 is on topic as Eric mentioned. So thanks there
> again. Since it is a 1D array can I drop the number in
> <<getMatrix>>?

>> Ben Bacarisse wrote:
>>> Michael <michaelk...@googlemail.com> writes:

>>>> Tom St Denis wrote:
>>>>>> int main( void )
>>>>>> {
>>>>>>    double A[3][3];

>>>>>>    void (*fnc)(double M[][]) = getMatrix;

>>>>>>    (*fnc)( A );

>>>>>>    printf("[ %.1f, %.1f]\n", A[0][0], A[0][1]);
>>>>>>    printf("[ %.1f, %.1f]\n", A[0][2], A[1][0]);

>>>>>>    return 0;}
>>>>> Probably the easier way to do this sort of anonymous thing is use a 1D
>>>>> array then access it via macro

>>>>> #define M(i, j) R[i*width+j]

>>>>> Where "width" is a constant that the compiler can optimize [e.g. *4 ==
>>>>> <<2 and so on, or more importantly just access the array with known
>>>>> offsets if it unrolls your code or whatever].
>>>> Thanks for your fast reply. If I got it right, you suggest to avoid
>>>> the use of a 2D array and stick to 1d one. Properly I missed your
>>>> point how to implement it, but does it require a change in getMatrix?

>>>> I didn't mentioned it clearly in the first posting: the "getMatrix"
>>>> function is generated "somewhere else". Thus, I have no control
>>>> there. I could post process the function and try to change the
>>>> definitions, but i would prefer to leave these functions untouched.
>>> Can you change the type?  If so there is another way: and array of
>>> pointers -- each one points to the start of a 1D array.  Access looks
>>> exactly the same so the body of the getMatrix code is the same.

>>> The advantage is that you can access the 2x2 part of, say, a 3x3
>>> matrix seamlessly this way (which, unless I've misread the situation
>>> is you problem).  The down side is that it is more complex to allocate
>>> and free such things.
>> Hi, well that sounds good to me. I cannot change the the type during
>> the "creation" of the function, but it looks to me that I can do the
>> change afterwards automatically.

> I'm sorry, but I don't understand this.  However, I don't really need
> to!  If the solution works for you, then I'm happy.

> Yes, see later.  Note that there is no point in writing a prototype
> for a function just before a "full" definition of it (though it does
> no harm either).  You /can/ define a function in such a way that it
> doesn't act as a prototype as well, but why would you?

>>   for( nI=0; nI<3; nI++)
>>     A[nI] = malloc( 3*sizeof(*A[nI]));

> You can, if you like, do one allocation of 9 items and set three
> pointers into that one allocation.  I might do it like this:

>   if ((A[0] = malloc(rows * columns * sizeof *A[0])) != NULL)
>       for (r = 1; r < rows; r++)
>           A[r] = &A[columns * r];

> For one thing, it simplifies the test of malloc's return result.

>>   for( nI=0; nI<3; nI++)
>>     A[nI] = malloc( 3*sizeof(*A[nI]));

> You can, if you like, do one allocation of 9 items and set three
> pointers into that one allocation.  I might do it like this:

>   if ((A[0] = malloc(rows * columns * sizeof *A[0])) != NULL)
>       for (r = 1; r < rows; r++)
>           A[r] = &A[columns * r];

>>>   for( nI=0; nI<3; nI++)
>>>     A[nI] = malloc( 3*sizeof(*A[nI]));

>> You can, if you like, do one allocation of 9 items and set three
>> pointers into that one allocation.  I might do it like this:

>>   if ((A[0] = malloc(rows * columns * sizeof *A[0])) != NULL)
>>       for (r = 1; r < rows; r++)
>>           A[r] = &A[columns * r];
>                    ^^
> is the "&" correct?

> <snip: most about passing 2D array>

>> Yup.  In fact, some people prefer to write:

>>  void getMatrix( double M[][] ) { ... }

>> because it makes the "arrayness" more explicit.  You can also write:

> Not standardly. In C89 it *may* work; the element type must be
> complete (i.e. not itself array-of-unspecified), but it is not clear
> if that is enforced before or after the 'adjustment' of an array
> parameter to pointer (and pointer to array-of-unspecified is OK).
> I have in fact had implementations go both ways on this point.

> > On Fri, 30 Oct 2009 13:32:08 +0000, Ben Bacarisse
> > <ben.use...@bsb.me.uk> wrote:
> >>  void getMatrix( double M[][] ) { ... }
> > Not standardly. In C89 it *may* work; the element type must be
> > complete (i.e. not itself array-of-unspecified), but it is not clear
> > if that is enforced before or after the 'adjustment' of an array
> > parameter to pointer (and pointer to array-of-unspecified is OK).
> > I have in fact had implementations go both ways on this point.

> Just so I am clear, the "both" ways you refer to are:

> (a) silently accepting the parameter's type as if it have been
> written double (*M)[] and