Const array of arrays as function argument

I think this resource explains it nicely. In general, it depends what "depth" of const guarding you need. If you want function "f" to have read-only access on both the "outer" pointer, the pointer it points to (the "inner" pointer), and the char the "inner" pointer points to, then use

const char *const *const strings

If you want to relax the guards to make this legal:

strings = NULL;

Then use:

const char *const *strings

Relaxing further, to allow for:

strings = NULL;

*strings = NULL;

Use only one "const":

const char **strings

It is important to understand the difference between an array of arrays (for example, an array of arrays of 2 chars) and an array of pointers. As the wording suggests, their element type is totally different:

• Each single element of an array of arrays, like my_arr_of_arrays below, is, well, an array! Not an address, not a pointer: Each element is a proper array, each of the same size (her: 2), a succession of a fixed number of sub-elements. The data is right there in the array object. After char my_arr_of_arrays[][2] = { "a", "b", "c", "" };, my_arr_of_arrays is a succession of characters, grouped in pairs: 'a', '\0', 'b', '\0', 'c', '\0', '\0', '\0'. The picture below illustrates that. Each element in my_arr_of_arrays has a size of 2 bytes. Each string literal is used to copy the characters in it into the corresponding array elements of my_arr_of_arrays. The data can be overwritten later, the copy is not const.

• Contrast this with an array of pointers, like my_arr_of_ptrs below! Each element in such an array is, well, a pointer. The data proper is somewhere else! The actual data may have been allocated with malloc, or it is static data like the string literals in my example below. Each element — each address — has a size of 4 byte on a 32 bit architecture, or 8 byte on a 64 bit architecture. Nothing is copied from the string literals: The pointers simply point to the location in the program where the literals themselves are stored. The data is const and cannot be overwritten.

It is confusing that these completely different data structures can be initialized with the same curly-braced initializer list; it is confusing that string literals can serve as a data source for copying characters over into an array, or that their address can be taken and assigned to a pointer: Both char arr[3] = "12": and char *ptr = "12"; are valid, but for arr a copy is made and for ptr the address of the string literal itself is taken.

Your program shows that C permits you to pass an address of an array of 2 chars to a function that expects the address of a pointer; but that is wrong and leads to disaster if the function tries to dereference an "address" which is, in fact, a sequence of characters. C++ forbids this nonsensical conversion.

The following program and image may shed light on the data layout of the two different arrays.

#include <stdio.h>

void f_array_of_arrays(char(* const arr_of_arrays)[2])
{
    for (int i = 0; arr_of_arrays[i][0] != 0; i++)
    {
        printf("string no. %d is ->%s<-\n", i, arr_of_arrays[i]);
    }

    const char myOtherArr[][2] = { "1", "2", "3", "4", "" };
    // arr2d = myOtherArr; //  <-- illegal: "const arr2d"!
    arr_of_arrays[0][0] = 'x';     // <-- OK: The chars themselves are not const.
}

void f_array_of_pointers(const char** arr_of_ptrs)
{
    for (int i = 0; arr_of_ptrs[i][0] != 0; i++)
    {
        printf("string no. %d is ->%s<-\n", i, arr_of_ptrs[i]);
    }
    arr_of_ptrs[1] = "87687686";
    for (int i = 0; arr_of_ptrs[i][0] != 0; i++)
    {
        printf("after altering: string no. %d is ->%s<-\n", i, arr_of_ptrs[i]);
    }
}

int main()
{
    char my_arr_of_arrays[][2] = { "a", "b", "c", "\0" };  // last element has two zero bytes.
    const char* my_arr_of_ptrs[] = { "111", "22", "33333", "" }; // "jagged array"

    f_array_of_arrays(my_arr_of_arrays);
    f_array_of_pointers(my_arr_of_ptrs);

    // disaster: function thinks elements are arrays of char but
    // they are addresses; does not compile as C++
    // f_array_of_arrays(my_arr_of_ptrs); 

    // disaster: function thinks elements contain addresses and are 4 bytes,
    // but they are arbitrary characters and 2 bytes long; does not compile as C++
    // f_array_of_pointers(my_arr_of_arrays);
}