Passing params to function and casting - c

Question

I am new to C language and I have some misunderstanding in the following exercise:
void printAllStrings(const char** arr[])
{
while(*arr!=NULL)
{
char** ptr=(char**)*arr;
while(*ptr!=NULL)
{
printf("%s\n",*ptr);
ptr++;
}
arr++;
}
}
int main()
{
char* arrP1[]={"father","mother",NULL};
char* arrP2[]={"sister","brother","grandfather",NULL};
char* arrP3[]={"grandmother",NULL};
char* arrP4[]={"uncle","aunt",NULL};
char** arrPP[]={arrP1,arrP2,arrP3,arrP4,NULL};
printf("Before sort :\n");
printAllStrings(arrPP);
sort(arrPP);
printf("\nAfter sort :\n");
printAllStrings(arrPP);
printf("\nMaximum length string : %s \n",maxLengthString(arrPP));
return 0;
}
The code above prints all strings.
My questions is:
In printAllStrings function the the passed parameter(char** arr[]) array of strings, could we pass pointer on pointer - char** arr.
What the meaning of this row char** ptr=(char**)*arr; I undersatnd that this casting of pointers to char type.
But why the pointer have to be casted is already points to char type?

Answer 1

In printAllStrings function the the passed parameter(char** arr[]) array of strings, could we pass pointer on pointer - char** arr[].
In your examples above, you have char** arr[] and char** arr[] (the two are the same) so your "could we pass?" question is unclear. If you are asking if you could change the parameter to (char ***arr), then yes, you could because the first level of indirection (e.g. [ ]) is converted to a pointer.
What the meaning of this row char** ptr=(char**)*arr; I undersatnd that this casting of pointers to char type. But why the pointer have
to be casted is already points to char type?
The reason is your parameter is const char** arr[] and then you declare char** ptr which discards the const qualifier on arr. const char ** and char ** are not the same. So when you attempt to initialize ptr with the dereferenced arr, e.g. (char** ptr=arr;) the compiler complains about the discard of the const qualifier.
Rather than fixing the problem correctly, e.g.
const char **ptr = *arr;
you "fudge" the initialization to force the discard of the const qualifier -- resulting in ptr not retaining the const type which can prevent the compiler from warning when you attempt to use ptr in a non-constant way (really bad things happen when you just cast away const qualifiers)
I may be wrong -- but it looks like the point of the assignment is to have you preserve the const nature of the string literals you use to initialize your array of pointers. So rather than declaring the arrays as:
char* arrP1[]={"father","mother",NULL};
You should declare them as arrays of const pointers to char, e.g.
const char *arrP1[]={"father","mother",NULL};
Your parameter for printAllStrings then makes sense, and the compiler with warn if you try and do something you are not allowed to do like changing the string literals, e.g. if you try:
arrP1[0][0] = 'l';
(the compiler will throw error: assignment of read-only location ‘*arrP1[0])
If you carry the types consistently through your code, you will not have to "fudge" with any casts anywhere, and the compiler can help protect you from yourself. For example, a simple rework of your types to make sure your string literals are const qualified (while still allowing you to sort your arrays) could be done with something like:
#include <stdio.h>
#include <string.h>
void printAllStrings (const char **arr[])
{
while (*arr != NULL) {
const char **ptr = *arr;
while (*ptr != NULL) {
printf ("%s\n", *ptr);
ptr++;
}
arr++;
}
}
const char *maxLengthString (const char **arr[])
{
size_t max = 0;
const char *longest = NULL;
while (*arr != NULL) {
const char **ptr = *arr;
while (*ptr != NULL) {
size_t len = strlen (*ptr);
if (len > max) {
max = len;
longest = *ptr;
}
ptr++;
}
arr++;
}
return longest;
}
int main (void) {
const char *arrP1[] = {"father", "mother", NULL};
const char *arrP2[] = {"sister", "brother", "grandfather", NULL};
const char *arrP3[] = {"grandmother", NULL};
const char *arrP4[] = {"uncle", "aunt", NULL};
const char **arrPP[] = {arrP1, arrP2, arrP3, arrP4, NULL};
printf ("Before sort :\n");
printAllStrings (arrPP);
// sort (arrPP); /* you didn't post sort, so the following swaps */
const char **tmp = arrPP[0]; /* simple swap example */
arrPP[0] = arrPP[1];
arrPP[1] = tmp;
printf ("\nAfter sort :\n");
printAllStrings (arrPP);
printf ("\nMaximum length string : %s \n", maxLengthString (arrPP));
return 0;
}
(You didn't post sort(), so above the elements a simply swapped to show your arrPP retains the ability to be sorted, and a quick implementation of the maxLengthString () was added to make your last statement work -- but note, it just finds the first of any longest strings if more than one are the same length)
Example Use/Output
$ ./bin/array_ptp_const_char
Before sort :
father
mother
sister
brother
grandfather
grandmother
uncle
aunt
After sort :
sister
brother
grandfather
father
mother
grandmother
uncle
aunt
Maximum length string : grandfather
Look things over and let me know if you have further questions. I'm not sure if this is what you were looking for, but based on your code and questions, it seemed the most logical choice.

Answer 2

I can only answer the 2nd question as I can not understand the 1st the way it is now.
char** ptr=(char**)*arr;
// this is the same but maybe confusing because arr is a pointer now and it gets iterated in the loop.
char** ptr=(char**)arr[0];
arrhas the type pointer (decayed from an array) to pointer to pointer to char.
ptrhas the type pointer to pointer to char.
As you can see ptr has one level of reference less than arr. arrholds all the pointers to your declared arrays of type pointer to char. (arrP1, arrP2, arrP3, arrP4).
By dereferencing arr you get the pointer to one of these arrays.(arrP1 in the first iteration)
Then you print where the pointer stored in ptr[0] points to and iterate to ptr[1], to print this. After the loop arrgets iterated and yields the pointer to arrP2 and you start again with the ptr-loop.
You have to keep in mind that arrays and pointers are quite similar(but not exactly the same) in their usage and passing an array to function lets it decay to a pointer.
Edit: David's answer is great, I misread the focus of the 2nd question, so this answer is a bit offtopic. I will leave it here, because I think it still helps understanding what happens with all the pointer magic. For a relevant answer especially about const correctness David's answer is the one.