I am having immense trouble with a small detail.. I have an array of
structures declared thus:

struct foo bar[4];

I want to pass the address of this to a function f, so that I in f can
do ``bar[1]->member = 1;'' to access bar[1]'s members.

I have tried many declarations for f, including this one, that I believe
is the correct one:

void f(struct foo (*bar)[4])
{

void f(int *a,int n){
   /* n is the number of elements in the array. it's unused here
   * but is generally needed in the function.
   */
   a[0]=9;

void f(struct foo *bar,int n){
   bar[0].i=3; /* suposing there is a member i in a struct bar */

void f(struct foo *bar) {

void f(struct foo bar[]) {

void f(struct foo bar[4]) {

struct foo bar[4];

? It's a 'struct foo'. Thus we get a pointer to struct foo, and that is what
must be declared as the formal parameter of the function. A declaration of a
parameter as an array of type is adjusted to a pointer to type.

As you cannot pass an array to a function, you normally must pass the size
of the array as an explicit extra parameter. A way around this, is to pass
the pointer to the array object instead, this is easily done with a typedef:

typedef struct foo {
/* */

struct foo {
/* */

Thanks for a quick answer, I was about to go crazy over this one..
Probably me just being stressed, since I have to have this game finished
by Thursdag... :(

Since this is adequate for almost every purpose, you reference the
individual elements of the array in the function as y[i].  This has
type T.  In your case, T is struct foo.  Therefore you would use
y[i].member.

If you really, really need to pass the address of the array, as in
func(&x), then you define the function as you describe.  However, it
still doesn't do what you want.  In your function, bar is a pointer to
an array of 4 struct.  Therefore bar[i] is the i-th such array.  That
is, bar[i] is an array of 4 struct.  bar[i][j] is the j-th struct in
that array.  You would have to use bar[i][j].member to refer to a
member.

The only way you can use bar[i]->member is if bar[i] is a pointer to
struct which requires that bar be either a pointer to pointer to
struct (as in struct foo **bar) or that bar be an array of pointers
(as in struct foo *bar[]).  However, your opening statement says you
have an array of struct, not an array of pointers to struct so you
probably don't really want this after all.

The real question becomes why don't you want bar[i].member which is
the "normal" situation?

Thanks for your explanatory answer.

[snip]