Passing structure arrays to functions in c programming

Why are you using array of pointers. Instead of this:

void Gender(struct strPerson *arPeople[5])
{
    char cSexMF = 'M';

    printf("Please enter 'M' to search for male members of staff or 'F' to search for female memebers of staff : \n\n");
    scanf("%c \n", &cSexMF);

    printf(".... %c ... %c ....\n", cSexMF, arPeople[0].cSex);
}

Do this (this is how you typically pass arrays to functions as parameters in C):

void Gender(struct strPerson arPeople[], int arrLength)
{
    // Enter search criteria
    char cSexMF = 0;
    printf("Please enter 'M' to search for male members of staff or 'F' to search for female memebers of staff : \n\n");
    scanf(" %c", &cSexMF);

    // Go through array
    for(int i = 0; i<arrLength; i++)
    { 
      // Check gender of each element of array against what user entered
      if(arPeople[i].cSex == cSexMF)
      {
        printf(".... %c ... %c .... %s\n", cSexMF, arPeople[i].cSex, arPeople[i].arcFirstName);
      }
    }
}

This should print names and also gender of people whose gender matches what user entered; you can apply such technique to other methods of yours too, like I said I doubt you need to use this construct: struct strPerson *arPeople[5], in your case.

Let's start with the basics: in C/C++ when evaluating expressions, the "maximum munch" rule applies, which is go right as much as possible and still get a valid expression, then go left.

how this applies here? let's evaluate your data declaration

struct strPerson *arPeople[5] 

1. start with your variable: arPeople
2. go right: arPeople is an array of 5 elements arPeople[5]
3. go left since you cannot go right anymore: you have an array of 5 elements which are pointers *arPeople[5]
4. go right: you have an array of 5 pointers to strPerson strPerson *arPeople[5]

Now, back to your problem: arrays are treated the same as pointers by the compiler; take the following declaration:

int *p0;
int p1[20];

Both p0 and p1 are pointers from the compiler's point of view: p0[0] and p1[1] represent the first element, p0++/p1++ increment the address and so on. That is not to say pointers are the same as arrays, they are just treated the same.

When you want to pass in an array as argument, the following function prototypes do the same thing:

void foo(int* p);
void foo(int p[]);
void foo(int p[10]);

The compiler will generate the exact same code for them, and from it's point of view you are passing in the address to the start of the data block.

If you want to modify the array struct strPerson arPeople[5] then your function prototypes should simply be:

void Gender(struct strPerson *arPeople);
OR
void Gender(struct strPerson arPeople[]);

For all the above mentioned reasons.

Hope this helps clear up things...

Except when it is the operand of the sizeof or unary & operators, or is a string literal being used to initialize another array in a declaration, an expression of type "N-element array of T" will be converted ("decay") to an expression of type "pointer to T", and the value of the expression will be the address of the first element of the array.

Also, in the context of a function parameter declaration, a declaration of the form T a[] or T a[N] will be treated as T *.

In the function call

Gender(arPeople);

the expression arPeople is converted from type "5-element array of struct strPerson" to "pointer to struct strPerson", or struct strPerson *.

Thus, your function declaration and definition need to be written as

void Gender( struct strPerson *arPeople )

In your code, you declare the arPeople parameter as an array of pointers, which according to the second rule above is treated as a pointer to a pointer, which is where your error message is coming from. Note that you can use the subscript operator [] on a pointer expression, so you can still write expressions like

printf(".... %c ... %c ....\n", cSexMF, arPeople[0].cSex); 

You could pass an actual pointer to the array, like so:

Gender( &arPeople );

Since in this case the expression arPeople is the operand of the unary & operator, it isn't converted to a pointer type; the type of the expression &arPeople is "pointer to 5-element array of struct strPerson", or struct strPerson (*)[5]. In this case, your function declaration and definition would need to be written as

void Gender( struct strPerson (*arPeople)[5] )

I don't recommend this for two reasons. First, your function will only ever be able to deal with 5-element arrays, which isn't terribly flexible (a pointer to a 5-element array is not compatible with a pointer to a some-number-other-than-5-element array). Second, in the body of your code, you must dereference the pointer before applying the subscript, like so:

printf(".... %c ... %c ....\n", cSexMF, (*arPeople)[0].cSex); 
                                        ^^^^^^^^^^^

which honestly just clutters things up.

Some style notes:

You don't want to pass an array without also passing its size, since the receiving function only gets a pointer to the first element, not an actual array object. I recommend you change your functions to take an additional size argument:

void Gender( struct strPerson *arPeople, size_t arSize )

and call it as

Gender( arPeople, sizeof arPeople / sizeof *arPeople );

This way your Gender function knows how many elements are in the array.

Secondly, for ease of maintenance, you can define your functions before the main function, like so:

void Gender( struct strPerson *arPeople, size_t arSize )
{
  // code for Gender function
}

void Surname( struct strPerson *arPeople, size_t arSize )
{
  // code for Surname function
}
...
int main( void ) 
{
  // code for main function
}

This way you don't have to worry about keeping the function declarations and definitions in sync. It does make your code read "backwards", but trust me, from a maintenance perspective this makes things a lot simpler.