When you are doing string_copy(my_array), you are passing a char (*)[100], i.e. pointer to char[100] array to your function. But your function is expecting a char *[], i.e. array of char pointers, because you have defined your function that way.

You can fix this by making changes so that your function (string_copy()) expects a char (*)[100], instead of a char *[].

For this, you can change your function definition as:

/* Your my_array gets converted to pointer to char[100]
   so, you need to change your function parameter
   from `char *pointer[]` to `char (*pointer)[100]` 
*/ 
/* static void string_copy(char *pointer []) */
static void string_copy(char (*pointer) [100])
{
    strcpy(pointer[0], "Hello ");
    strcpy(pointer[1], "world");
}

* Alternative Solution *

A different design/solution would be to change in your main() function so that you are actually passing a char *[], which decays into a char ** - which is fine - to string_copy(). This way you would NOT have to change your string_copy() function.

int main(int argc, const char * argv[]) {

    char my_array[10][100];
    int tot_char_arrs, i;
    char *char_arr_ptr[10];

    /* Get total number of char arrays in my_array */
    tot_char_arrs = sizeof(my_array) / sizeof(my_array[0]);

    // Store all char * 
    for (i = 0; i < tot_char_arrs; i++)
            char_arr_ptr[i] = my_array[i];

    /* Actually passing a char *[].
       it will decay into char **, which is fine
     */
    string_copy(char_arr_ptr);

    printf("%s%s\n", my_array[0], my_array[1]);
}

You can do it like this:

void sort(char **, int);
int main()
{
    char *string_database[5]={'\0'};
    string_database[0]="Florida";
    string_database[1]="Oregon";
    string_database[2]="California";
    string_database[3]="Georgia";

    sort(string_database, 4);
    return 0;
}

void sort(char **str, int n)
{
    int i = 0;
    for (i = 0; i < n; i++)
      printf("The string is= %s\n",str[i]);

}

You've already got it.

#include <stdio.h>
static void func(char *p[])
{
    p[0] = "Hello";
    p[1] = "World";
}
int main(int argc, char *argv[])
{
    char *strings[2];
    func(strings);
    printf("%s %s\n", strings[0], strings[1]);
    return 0;
}

In C, when you pass an array to a function, the compiler turns the array into a pointer. (The array "decays" into a pointer.) The "func" above is exactly equivalent to:

static void func(char **p)
{
    p[0] = "Hello";
    p[1] = "World";
}

Since a pointer to the array is passed, when you modify the array, you are modifying the original array and not a copy.

You may want to read up on how pointers and arrays work in C. Unlike most languages, in C, pointers (references) and arrays are treated similarly in many ways. An array sometimes decays into a pointer, but only under very specific circumstances. For example, this does not work:

void func(char **p);
void other_func(void)
{
    char arr[5][3];
    func(arr); // does not work!
}

The warning is exactly right. Your function wants an array of pointers. You're giving it an array of arrays.

Expected:

 sep_foo:
 +------+       +-----+
 |char**|--> 0: |char*|-->"string1"
 +------+       +-----+
             1: |char*|-->"string2"
                +-----+
*sep_foo_qty-1: |...  |
                +-----+

What you provided:

           sep_foo:
           +--------------------------------+
        0: | char[MAX_STRING_LENGTH]        |
           +--------------------------------+
        1: | char[MAX_STRING_LENGTH]        |
           +--------------------------------+
MAX_QTY-1: | ...                            |
           +--------------------------------+

An array with elements of type X can "decay" into a pointer-to-X, or X*. But the value of X isn't allowed to change in that conversion. Only one decay operation is allowed. You'd need it to happen twice. In your case, X is array-of-MAX_STRING_LENGTH-chars. The function wants X to be pointer-to-char. Since those aren't the same, the compiler warns you. I'm a bit surprised it was just a warning since nothing good can come from what the compiler allowed to happen.

In your function, you could write this code:

char* y = NULL;
*sep_foo = y;

That's legal code since sep_foo is a char**, so *sep_foo is a char*, and so is y; you can assign them. But with what you tried to do, *sep_foo wouldn't really be a char*; it would be pointing to an array of char. Your code, in effect, would be attempting to do this:

char destination[MAX_STRING_LENGTH];
char* y = NULL;
destination = y;

You can't assign a pointer into an array, and so the compiler warns that the call is no good.

There are two ways to solve this:

• Change the way you declare and allocate sep_foo on the calling side so it matches what the function expects to receive:

  char** sep_foo = calloc(MAX_QTY, sizeof(char*));
  for (int i = 0; i < MAX_QTY; ++i)
    sep_foo[i] = malloc(MAX_STRING_LENGTH);
  

  or, equivalently

  char* sep_foo[MAX_QTY];
  for (int i = 0; i < MAX_QTY; ++i)
    sep_foo[i] = malloc(MAX_STRING_LENGTH);
  

• Change the prototype of the function to accept what you're really giving it:

  int parse(const char *foo, char sep_foo[MAX_QTY][MAX_STRING_LENGTH], int *sep_foo_qty);
  

As coded, printer takes a string and prints every final substring. You pass *words, which is the same as words[0], ie: the first string in the 2D array.

To pass a pointer to the array, the type of the argument should be char array[][10]^(*).:

#include <stdio.h>

char words[][10] = { "madam", "Russia", "India", "Japan", 
                     "China", "Brazil", "Mexico" };
int size = sizeof(words) / sizeof(words[0]);

void printer(char words[][10], int len);

int main() {
    printer(words, size);
    return 0;
}

void printer(char words[][10], int len) {
    for (int i = 0; i < len; i++) {
        printf("%s\n", array[i]));
    }
}

Note however that you could also define array as an array of pointers to character strings char *array[]. This would allow for strings of any length, not limited to 9 characters plus a null terminator.

The code would be changed to this:

#include <stdio.h>

char *words[] = { "madam", "Russia", "India", "Japan", 
                  "China", "Brazil", "Mexico" };
int size = sizeof(words) / sizeof(words[0]);

void printer(char *words[], int len);

int main() {
    printer(words, size);
    return 0;
}

void printer(char *words[], int len) {
    for (int i = 0; i < len; i++) {
        printf("%s\n", array[i]));
    }
}

The array words is initialized from string literals, which must not be changed, so it would be better to define it as const char *array[] and modify printer accordingly. Note also that printf("%s\n", array[i])) is equivalent to puts(array[i]) (good compilers detect this equivalence and generate the call to puts in both cases):

#include <stdio.h>

const char *words[] = { "madam", "Russia", "India", "Japan", 
                        "China", "Brazil", "Mexico" };
int size = sizeof(words) / sizeof(words[0]);

void printer(const char *words[], int len);

int main() {
    printer(words, size);
    return 0;
}

void printer(const char *words[], int len) {
    for (int i = 0; i < len; i++) {
        puts(array[i]);
    }
}

^{(*) The function does not receive an actual 2D array as argument, but a pointer to the array of arrays, which technically has type char (*)[10] but the compiler will accept both syntaxes equivalently and char array[][10] is simpler and more readable}

Does this work?

#include <string.h>
#include <assert.h>
#include <stdio.h>

int format_parameters(char *str, char *param[], size_t nparam)
{
    char **next = param;
    char **end  = param + nparam;
    char  *data = str;

    assert(str != 0 && param != 0 && nparam != 0);

    while (next < end && *data != '\0')
    {
        *next++ = data;
        data = strchr(data, ' ');   // Choose your own splitting criterion
        if (data == 0)
            break;
        *data++ = '\0';
    }
    return(next - param);
 }

 int main(void)
 {
     char  str[] = "a b c d";
     char *param[5];
     int   nvals = format_parameters(str, param, 5);
     int   i;

     for (i = 0; i < nvals; i++)
         printf("Param %d: <<%s>>\n", i+1, param[i]);

     return 0;
  }

The return value is the number of parameters found. If you pass an empty string, that would be 0. Beware leading, trailing and repeated blanks; the code works - but maybe not as you want it to.

This is because arrays decay into pointers to their first element when passed to a function like yours, and there is no information retained about the number of elements. In the scope where the array is declared, this decay hasn't happened, so sizeof works.

You must either add length of array as an extra argument, or make sure the array is terminated by an appropriate sentinel value. One popular such value is NULL, i.e. you make sure the last valid index holds a string pointer whose value is NULL, which then indicates "no more data, stop":

const char *menu[] =
{
    "Customers",
    "Orders",
    "Products",
    NULL /* This is a sentinel, to mark the end of the array. */
};

If your string array will remain with those sizes then the best way is to use

void function (char (* cppStringArray)[512], size_t num_strings);

pass as

function(cStringArray, sizeof(*cStringArray)/sizeof(cStringArray));

Problem is that char** is not equivalent to char (*)[512]. The former is a pointer to pointer to char. The latter is a pointer to a block of 512 characters.

char array_slave_1[128][128]

This is 2-dimensional array of char as paramter:

int array_length(char *a[])

This is array of pointers to char (which might be C strings, but could be other char/byte buffers, or single chars too). Except because it is a function parameter, it really is pointer to pointer, so if you are a novice you'd be better off writing what it really is, to avoid getting confused:

int array_length(char **a)

Types of array_slave_1 and a are fundamentally different, and incompatible.

If you want to make your function take the array as parameter, you could do:

int array_length(char a[][128])

which is same as this (note the extra () compared to code in question, they matter!), because array parameters really are pointers, so you have a pointer to one or more char[128] buffers:

int array_length(char (*a)[128])

Then you need a different way to determine the array length, though. Perhaps empty string means end of strings? That's up to you, really.

Alternative is to change your array to be array of pointers:

char *array_slave_1[128]; // 128 pointers to char buffer or C string
// remember that you must allocate the space of each string!

Inside the function parameter list, char arr[] is absolutely equivalent to char *arr, so the pair of definitions and the pair of declarations are equivalent.

void function(char arr[]) { ... }
void function(char *arr)  { ... }

void function(char arr[]);
void function(char *arr);

The issue is the calling context. You provided a string literal to the function; string literals may not be modified; your function attempted to modify the string literal it was given; your program invoked undefined behaviour and crashed. All completely kosher.

Treat string literals as if they were static const char literal[] = "string literal"; and do not attempt to modify them.