const keyword and pointer

Yoshi · Nov 29, 2009

Hello,

I encountered following code when I was reading man page of qsort.

In the function compstringp, it casts p1 and p2 to ( char * const * ).
I re-read the C-Faq and still don't understand what it means.

Does ( char * const * ) means, cast to "pointer to const pointer to
char"? Does it make sense to cast this way ?

static int
cmpstringp(const void *p1, const void *p2)
{
/* The actual arguments to this function are "pointers to
pointers to char", but strcmp(3) arguments are "pointers
to char", hence the following cast plus dereference */

return strcmp(* (char * const *) p1, * (char * const *) p2);
}

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

assert(argc > 1);

qsort(&argv[1], argc - 1, sizeof(argv[1]), cmpstringp);

for (j = 1; j < argc; j++)
puts(argv[j]);
exit(EXIT_SUCCESS);
}

Thank you

Ben Bacarisse · Nov 29, 2009

Yoshi said:
I encountered following code when I was reading man page of qsort.

In the function compstringp, it casts p1 and p2 to ( char * const * ).
I re-read the C-Faq and still don't understand what it means.

Does ( char * const * ) means, cast to "pointer to const pointer to
char"?
Yes.

Does it make sense to cast this way ?

Yes. qsort passes a pair of pointers to the compare function. Each
one points to one of the things being compared. argv is an array of
pointers to char (the initial character of each argument string) so
qsort passes values of type char **.

As for the const, the pointers that cmpstringp gets are const pointers
so we cast to char * const * rather than unadorned char **.

static int
cmpstringp(const void *p1, const void *p2)
{
/* The actual arguments to this function are "pointers to
pointers to char", but strcmp(3) arguments are "pointers
to char", hence the following cast plus dereference */

return strcmp(* (char * const *) p1, * (char * const *) p2);
}

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

assert(argc > 1);

qsort(&argv[1], argc - 1, sizeof(argv[1]), cmpstringp);

for (j = 1; j < argc; j++)
puts(argv[j]);
exit(EXIT_SUCCESS);
}

I leave the above for context.

mohangupta13 · Nov 29, 2009

Yes. qsort passes a pair of pointers to the compare function. Each
one points to one of the things being compared. argv is an array of
pointers to char (the initial character of each argument string) so
qsort passes values of type char **.

As for the const, the pointers that cmpstringp gets are const pointers
so we cast to char * const * rather than unadorned char **.

what i also fail to understand is the above line ,
strcmp expects const char * so why we don't cast them to that , why
has the cast *(char* const *) done ??

}

Click to expand...

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

Click to expand...

assert(argc > 1);

Click to expand...

qsort(&argv[1], argc - 1, sizeof(argv[1]), cmpstringp);

Click to expand...

for (j = 1; j < argc; j++)
puts(argv[j]);
exit(EXIT_SUCCESS);
}

Click to expand...

I leave the above for context.

Ben Bacarisse · Nov 29, 2009

what i also fail to understand is the above line ,
strcmp expects const char * so why we don't cast them to that , why
has the cast *(char* const *) done ??

You can cast to const char * const * if you like, but there is little
point. After the * operation, the value being passed to strcmp is of
type char * which can be passed to a function expecting const char *
with no problems.

<snip>

mohangupta13 · Nov 29, 2009

You can cast to const char * const * if you like, but there is little
point. After the * operation, the value being passed to strcmp is of
type char * which can be passed to a function expecting const char *
with no problems.

if the ultimate thing that is being passed in of type char* then why
are so many casts used in the first place ,
just use
return strcmp( (const char*) p1 ,(const char*) p2);

Ben Bacarisse · Nov 29, 2009

mohangupta13 said:
if the ultimate thing that is being passed in of type char* then why
are so many casts used in the first place ,
just use
return strcmp( (const char*) p1 ,(const char*) p2);

Those parameters are of the right type but the wrong values. p1 and
p2 don't point at chars. They point to char pointers:

+------+ +-------+
p1 | ---|------------------->| ---|------->"abc"
+------+ +-------+
| ---|------->"def"
+------+ +-------+
p2 | ---|------------------->| ---|------->"ghi"
+------+ +-------+

Yoshi · Nov 29, 2009

Yes. qsort passes a pair of pointers to the compare function. Each
one points to one of the things being compared. argv is an array of
pointers to char (the initial character of each argument string) so
qsort passes values of type char **.

As for the const, the pointers that cmpstringp gets are const pointers
so we cast to char * const * rather than unadorned char **.

Thank you for your answer, but why not simply cast to (const char **)
then?
when it is dereferenced, (const char **) becomes (const char*), which
matches strcmp prototype, and if (char *const *) is dereferenced, if
will become (char *const), which does not matches prototype.

Furthermore, I wonder why compiler does not complain even if I passed
simply char *, not const char*, whereas strcmp's prototype shows it
takes const char*?

--
Yoshi

static int
cmpstringp(const void *p1, const void *p2)
{
/* The actual arguments to this function are "pointers to
pointers to char", but strcmp(3) arguments are "pointers
to char", hence the following cast plus dereference */

Click to expand...

return strcmp(* (char * const *) p1, * (char * const *) p2);
}

Click to expand...

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

Click to expand...

assert(argc > 1);

Click to expand...

qsort(&argv[1], argc - 1, sizeof(argv[1]), cmpstringp);

Click to expand...

for (j = 1; j < argc; j++)
puts(argv[j]);
exit(EXIT_SUCCESS);
}

Click to expand...

I leave the above for context.

Ben Bacarisse · Nov 29, 2009

Yoshi said:
Thank you for your answer, but why not simply cast to (const char **)
then?

No reason other than you might get a message that you are removing
const-ness with a cast. In some sense, converting void const * to T
const * is more "correct" but there is nothing wrong with omitting the
const. Note that none of this has anything to do with the const in
your suggestion: whether we cast to const char ** or char ** does not
matter here, we are still removing the const from the void *.

when it is dereferenced, (const char **) becomes (const char*), which
matches strcmp prototype, and if (char *const *) is dereferenced, if
will become (char *const), which does not matches prototype.

"Matching" is not what matters here. The rules are subtle and I don't
really want to go find them all and quote them.

Whether a thing itself is const or not does not matter, so when passing
an argument char * const and char * are the same, and...

Furthermore, I wonder why compiler does not complain even if I passed
simply char *, not const char*, whereas strcmp's prototype shows it
takes const char*?

.... you can always add const-ness to the thing pointed to so a char *
argument is permitted when the function expects const char *.

Yoshi · Nov 30, 2009

No reason other than you might get a message that you are removing
const-ness with a cast. In some sense, converting void const * to T
const * is more "correct" but there is nothing wrong with omitting the
const. Note that none of this has anything to do with the const in
your suggestion: whether we cast to const char ** or char ** does not
matter here, we are still removing the const from the void *.

But it seems removing const from the void * does not matter also here.

"Matching" is not what matters here. The rules are subtle and I don't
really want to go find them all and quote them.

Whether a thing itself is const or not does not matter, so when passing
an argument char * const and char * are the same, and...