Correct C syntax for "address of" character pointer array?

Assuming you have an array declared as

char *a[N];

and you want to pass a pointer to the array, as in

foo( &a );

then the prototype for foo needs to be

void foo( char *(*aptr)[N] );

Note that in this case, the size of the array must be declared; a pointer to an N-element array is a different type from a pointer to an M-element array.

Normally, you don't want to do this; instead, you would normally just pass the array expression like so:

foo ( a );

and the corresponding prototype would be:

void foo ( char **aptr );

Except when it is the operand of thesizeof 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 toT", and the value of the expression will be the address of the first element of the array.

Updated Answer For Modified Problem Statement

Given what you have said in comments, there is no need to pass a pointer to an array. You can simply pass a pointer to the first element of the array. Such a pointer suffices because the remaining elements of the array are obviously located after the first element.

To write a function that sets pointers in an array of pointers to char, do this:

void MyFunction(int NumberToSet, char *Pointers[])
{
    for (int i = 0; i < NumberToSet; ++i)
    {
        Pointers[i] = SomeString;
    }
}

In the above, SomeString must have type “pointer to char”. This could be a string, such as "Hello", or an array of char (which is automatically converted to a pointer to char), or some identifier x that has been declared as char *x (and has been initialized or assigned), for example.

To use this function, call it like this:

char *MyArrayOfPointers[SomeNumber];
MyFunction(NumberOfPointersIWantToSet, MyArrayOfPointers);

Original Answer

In most cases, to pass an array of pointers to char to a function, it suffices to pass the address of the first element. In this case, you would use either of these (they are equivalent):

void myFunc(char **a)
void myFunc(char *a[])

If you truly want to pass the address of the array, you would use:

void myFunc(char *(*a)[])

In this case, the type of a is incomplete, since the dimension is missing. Depending on what you intend to do with a, you may need to provide the dimension in the declaration.

When calling myFunc and passing it some array declared as char *array[N];, you would pass it, in the former case, as myFunc(array) and, in the latter case, as myFunc(&array).

try this as a function definition void myFunc(char *a[]) or void myFunc(char **a) then use it this way :

char *arr[20];
myFunc(arr);

Ok you are almost on the right path. void myFunc(char *a[]);

Example

void fun(char *a[]){
    printf("%s",*a);    //for accessing the next element do a+1
    }

int main(void) {
    char *x[3];
    x[0]="abcd";
    fun(x);   // here you are passing the address first array element 
    return 0;

DEMO

Declaration

void myFunc(char &*a[]);  

is not a valid C syntax.
To pass the address of character pointer arrays, use this instead

void myFunc(char *(*a)[]);   

*(*a)[] in the above function declares a as pointer to array of pointers to chars. Must note that a has an incompatible type. A suffix is needed in [] to make it complete.

First of all, C is in general a "pass by reference" language. Some data items such as integers, floats, and single characters can be passed by value. But, arrays of those same data types are ALWAYS passed by reference.

Thus, when you say "I need to pass into a function the address of a character pointer array" then simply declare an array of character pointers in your function prototype as:

void myFunc(char *a[]);

Thus, char * declares a char pointer and a[] defines an array of them. To check this declaration refer to: http://www.cdecl.org/ which parses this expression as a "declare a as array of pointer to char".

The technical point is that the * binds with char rather than with a[].

So, C will pass a pointer to the data structure that you have declared. A discussion on this topic could delve into double pointers but for this question such a discussion is probably off topic.