Reallocating pointers of pointers of pointers - c

Question

As a part of our Computer Science course (using C), we are to build a VERY wasteful system using pointers
Since we are not allowed to use structures at this point, we are to use ONLY pointers for our dynamic-arrays.
I have created the dynamic-array **students and allocated space for it.
at this point, i send this dynamic array (**students) to a function that sends it to ANOTHER function (i send &students so i can change them by address)
My problem is, that i do not know (apparently - and after many many tries) how to reallocate space to this dynamic-array
To be specific, since i sent the array 2 times:
my first function receives ***students
and my second function receives ****students
I tried to reallocate space the following way (I am in the SECOND function at the moment)
*students = (char**)realloc(*students, 2 * sizeof(char*));
*students[1] = (char*)malloc(sizeof(char))
this seemed like the way to do it - apparently i was wrong
any help would be thankfully received :)
Edit:
The program will run if I do this:
**students = (char**)realloc(**students, 2 * sizeof(char*));
but then I am not able to use malloc correctly..
I would appreciate the understanding behind my question and not just a solution, so I can learn for next trial.

Answer 1

I have created the dynamic-array **students and allocated space for
it. at this point, i send this dynamic array (**students) to a
function that sends it to ANOTHER function (i send &students so i can
change them by address)
…
To be specific, since i sent the array 2 times: my first function
receives ***students and my second function receives ****students
There is no sense in taking the array pointer's address (i. e. &students) more than once, since we then already have the means to reallocate the array:
void ANOTHER_function(char ***students)
{
*students = realloc(*students, 2 * sizeof **students); // room for 2 char *
(*students)[1] = malloc(sizeof *(*students)[1]); // room for 1 char
}
void a_function(char ***students)
{
ANOTHER_function(students); // no need for address operator & here
}
int main()
{
char **students = malloc(sizeof *students); // room for 1 char *
students[0] = malloc(sizeof *students[0]); // room for 1 char
a_function(&students);
}
So, we don't need more than three * anywhere here.
When you had ANOTHER_function(char ****students) and therein
*students = (char**)realloc(*students, 2 * sizeof(char*));
the type of *students was char *** and didn't match the (char**) on the right - fortunately, because *students was the address of main's students instead of its value.
**students = (char**)realloc(**students, 2 * sizeof(char*));
was correct (albeit overly complicated) in this case; the corresponding malloc() for the new element would have been
(**students)[1] = malloc(sizeof *(**students)[1]);