passing 2D array pointer to function in C

This

char*** t_ptr = &t;

is wrong as compiler pointed because t is an two dimensional array, instead of triple pointer like char*** use pointer to an array to point to it. For e.g

char t[3][3] = { "ab","de","gh"}; /* total 3 1D array & each 1D array has 3 elements */
char (*t_ptr)[3] = t; /* t_ptr is a pointer to an array, pointing to 3 elements at a time */

And you can print t_ptr like

for(int index = 0; index < 3 ; index++) {
        printf("%s\n",t_ptr[index]);
}

For reading c declarations, you can visit: https://cdecl.org/

Now using @Achal's example array:

#include <stdio.h>
#include <stdlib.h>

int main()
{
    // t is a 2D array (not a VLA)

    char t[3][3] =
    {
        {'a', 'b', '\0'},
        {'d', 'e', '\0'},
        {'g', 'h', '\0'}
    };
    printf("t is composed of 3 arrays of 3 characters each,\n");
    printf("with the following addresses (on my machine):\n");
    printf("--------------------------------------------------\n");
    printf("%p, %p, %p\n", t[0], t[1], t[2]);


// ------------------------------------------------
    // p is an array of 3 char pointers or char*
    // Notice initialization
    char* p[3] = {t[0], t[1], t[2]};
    // following line of code will break, if no '\0' is encountered
    // since %s requires a char* and a null terminator

    printf("\nPrint strings using p:\n");
    printf("------------------------\n");
    printf("%s, %s, %s\n", *p, *(p + 1), *(p + 2));

// ------------------------------------------------
    // q is a pointer to a char* or q has type char**
    // Notice initialization of q (q points to p)

    char** q = p;
    printf("\nUsing q:\n");
    printf("-----------\n");
    printf("%s, %s, %s\n", *q, *(q + 1), *(q + 2));

// ---------------- printing characters individually
    printf("\nIndividually:\n");
    printf("---------------\n");
    for(int i = 0; i < 2; i++)
    {
        for(int j = 0; j < 2; j++)
        {
            printf("%c ",
                  *(*(q + i) + j)
                   );
        }
        printf("\n");
    }
// -----------------------------------------------
    // r is a pointer to an array of size 3 containing char
    // r advances three char at a time (r doesn't know the size of t)

    char (*r)[3] = t;   // this is the type of t
    printf("\nUsing r:\n");
    printf("---------------\n");
    printf("%p, %p, %p\n", *r, *(r + 1), *(r + 2));

    // to extract chars
    printf("%c, %c", *(*(r + 0) + 0), *(*(r + 2) + 1));
// -----------------------------------------------

    return EXIT_SUCCESS;
}

Output:

t is composed of 3 arrays of 3 characters each,
with the following addresses (on my machine):
--------------------------------------------------
000000000022FE2F, 000000000022FE32, 000000000022FE35

Print strings using p:
------------------------
ab, de, gh

Using q:
-----------
ab, de, gh

Individually:
---------------
a b
d e

Using r:
---------------
000000000022FE2F, 000000000022FE32, 000000000022FE35
a, h
Process returned 0 (0x0)   execution time : -0.000 s
Press any key to continue.

char t[N][N];

is in fact the same as

char t[N * N];

in memory. A pointer to such an array would in both cases be of type char *.

char *** is a pointer to a pointer, that is a pointer to a char, whereas char * is a pointer to a char and that's how you pass array references in C: You pass them as a pointer to the first element of that array and this first element is a char.

C cannot retain the exact type or structure of an array as soon as you pass it to functions. In memory, a char array is just a bunch of memory filled with chars and all you can pass around is a pointer to that memory. If that memory is char [] or char [][] or even char [][][] plays no role, in memory all three are a block full of chars and the function would have to explicitly know the structure in memory, otherwise all char arrays will always be char [] for a function.

I strongly discourage C beginners to ever use multidimensional arrays. Instead of

char t[N][N];
char c = t[y1][x1];
t[y2][x2] = 'X';

use

char t[N];
char c = t[y1 * N + x1];
t[y2 * N + x2] = 'X';

As that's basically what the compiler will internally do anyway.

Note that multidimensional arrays in C are not x-y, but y-x, the first value is the row, the second on the column, please see this tutorial.

Whoever disbelieves what I just said, try out this code:

int main ( ) {
    char a[5][5];
    for (int y = 0; y < 5; y++) {
        for (int x = 0; x < 5; x++) {
            a[y][x] = x + 10 * y;
        }
    }

    for (int y = 0; y < 5; y++) {
        for (int x = 0; x < 5; x++) {
            printf("%02d ", a[y][x]);
        }
        printf("\n");
    }

    printf("------\n");

    char * a2 = (char *)a;
    for (int y = 0; y < 5; y++) {
        for (int x = 0; x < 5; x++) {
            printf("%02d ", a2[y * 5 + x]);
        }
        printf("\n");
    }
}

You can run it online, if you like, the output is identical. Also have a look at the assembly code the compiler generates for either loop (e.g. gcc -S) and you will see it's almost identical as even in the first case the compiler uses an add and a mul instruction to access the correct memory location within the array.