FAQ 13.8, comparing strings

[arnuld]

On Mon, 28 Apr 2008 07:25:53 +0000, Richard Heathfield wrote:

#include <string.h>
int p_strcmp(const void *pv1, const void *pv2)
{
char * const * v1 = pv1;
char * const * v2 = pv2;
return strcmp(*v1, *v2);
}

Either you are not understanding me or I am not able to understand this
<p_strcmpthing. This is your code:

compare these 2 paragraphs:

In theory, you get a <pointer to const voidand you use it to initialize
a <pointer to a const pointer to char. In practice, you get a <pointer
to a pointer to charand you are using it to initialize a <pointer to a
const pointer to charand then dereference it to a <const pointer to
char>.
Because you already know that the input argument will be <char**so we
can simply dereference it and get a <char*which could be used for
<strcmpsince <strcmpdoes not require a <const pointer>. Hence It
could be simply this:
int p_strcmp(const void *pv1, const void *pv2)
{
return strcmp(*pv1, *pv2);
}
I need explanation on this as it<p_strcmpcode is biting me
from the very 1st day I saw it in section 13.8 of the FAQ and I still
can't seem to comprehend the WHY of it.

--
http://lispmachine.wordpress.com/
my email ID is at the above address
--
http://lispmachine.wordpress.com/
my email ID is at the above address

[vippstar]

On Apr 28, 7:00 pm, arnuld <[e-mail]:

On Mon, 28 Apr 2008 07:25:53 +0000, Richard Heathfield wrote:
#include <string.h>
int p_strcmp(const void *pv1, const void *pv2)
{
char * const * v1 = pv1;
char * const * v2 = pv2;
return strcmp(*v1, *v2);
}

Either you are not understanding me or I am not able to understand this
<p_strcmpthing. This is your code:

compare these 2 paragraphs:

In theory, you get a <pointer to const voidand you use it to initialize
a <pointer to a const pointer to char. In practice, you get a <pointer
to a pointer to charand you are using it to initialize a <pointer to a
const pointer to charand then dereference it to a <const pointer to
char>.

Because you already know that the input argument will be <char**so we

/You/ do know that. The compiler doesn't. In your code you dereference
a void * pointer and then use its value, which is not possible in ISO
C.

can simply dereference it and get a <char*which could be used for

How do you get a char * if you dereference a void *?

<strcmpsince <strcmpdoes not require a <const pointer>. Hence It
could be simply this:

int p_strcmp(const void *pv1, const void *pv2)
{
return strcmp(*pv1, *pv2);

Here, you dereference a void pointer as I said before. This void *
pointer is given the value of a char ** pointer. That's why RH assigns
it to such pointer, and then dereferences it. Consider this:

#include <stdio.h>
int f(void *p);
int main(void) {
int i = 10;
int *k = &i;
printf("%d\n", f(&k)); // pass address of int *, type is int **
return 0;
}
int f(void *p) {
int **i = p; // p points to an int **
return **i + 10;
}

It's the same thing.

P.S. Your signature appeared twice.

[arnuld]

On Mon, 28 Apr 2008 04:11:11 -0700, vippstar wrote:

#include <stdio.h>
int f(void *p);
int main(void) {
int i = 10;
int *k = &i;
printf("%d\n", f(&k)); // pass address of int *, type is int **
return 0;
}
int f(void *p) {
int **i = p; // p points to an int **
return **i + 10;
}

It's the same thing.

O...K..A..Y....

Now I got it. <void*is a compile-time phenomenon which , actually,
helps a lot as run-time phenomenon because in many cases we could know
the types only at run-time.
Right ?
still one questions remains:
#include <string.h>
int p_strcmp(const void *pv1, const void *pv2)
{
char * const * v1 = pv1;
char * const * v2 = pv2;
return strcmp(*v1, *v2);
}
I can use <char** v1 = pv1or <const char** v1 = pv1>

why use <char *const *v1 = pv1?


--
http://lispmachine.wordpress.com/
my email ID is at the above address

[Richard Heathfield]

arnuld said:

>On Mon, 28 Apr 2008 04:11:11 -0700, vippstar wrote:

>#include <stdio.h>
int f(void *p);
int main(void) {
int i = 10;
int *k = &i;
printf("%d\n", f(&k)); // pass address of int *, type is int **
return 0;
}
int f(void *p) {
int **i = p; // p points to an int **
return **i + 10;
}

It's the same thing.

O...K..A..Y....

Now I got it. <void*is a compile-time phenomenon which , actually,
helps a lot as run-time phenomenon because in many cases we could know
the types only at run-time.
Right ?
still one questions remains:
#include <string.h>
int p_strcmp(const void *pv1, const void *pv2)
{
char * const * v1 = pv1;
char * const * v2 = pv2;
return strcmp(*v1, *v2);
}
I can use <char** v1 = pv1or <const char** v1 = pv1>

Not correctly. Neither of those forms is compatible with const void *.

why use <char *const *v1 = pv1?

Think abstractly.

Let's say you have an array of objects of type T that you wish to qsort:

T foo[N] = {0};

populate(foo, N); /* get some values */

qsort(foo, N, sizeof foo[0], foocmp);

Whenever qsort needs to compare two objects, it will call foocmp, passing
it pointers to two elements in the foo array. Since these elements will be
of type T, the pointers will be of type T *. Since qsort's fourth
parameter is of type int (*)(const void *, const void *), foocmp must be
the name of (or at least a pointer to) a function of type int(const void
*, const void *) - so the parameters are required to be const-qualified.

We can convert the parameters back into the proper type like this:

const T *p1 = vp1;
const T *p2 = vp2;

or like this:

T const *p1 = vp1;
T const *p2 = vp2;

The two type forms are equivalent, and both mean "pointer to const T".

Plugging in char * in place of T, however, is complicated by the * in "char
*". We need "pointer to const pointer to char". So we can't do this:

const char * *p1 = vp1;

because that means "pointer to pointer to const char".

But we /can/ plug in directly to the second form:

char * const *p1 = vp1;

because /that/ means "pointer to const pointer to char", which is exactly
what we need.

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[santosh]

arnuld wrote:

<snip>

Now I got it. <void*is a compile-time phenomenon which , actually,
helps a lot as run-time phenomenon because in many cases we could
know the types only at run-time.

<snip>

Can you clarify this? What do you mean by "compile-time phenomenon"
and "run-time phenomenon"?

[Peter Nilsson]

santosh wrote:

arnuld wrote:

Now I got it. <void*is a compile-time phenomenon which,
actually, helps a lot as run-time phenomenon because in
many cases we could know the types only at run-time.

<snip>

Can you clarify this? What do you mean by "compile-time
phenomenon" and "run-time phenomenon"?

Sounds like the OP is drawing the distinction between object
type, which is known at compile time since C is statically
typed, and an object's effective type which need only be
known at runtime.

--
Peter

[arnuld]

On Mon, 28 Apr 2008 17:44:53 +0530, santosh wrote:

Can you clarify this? What do you mean by "compile-time phenomenon"
and "run-time phenomenon"?

of course :) . This is just what I came to think of about types in C. If
am wrong, poke me in the eye ;)

<void*points to no type, practically.

Lets us say that a C program asks the user for input, I can not enter some
words at standard input and make them of type <void>, they can be stored
in <array of charbut not in <array of void>. Section 13.8 of FAQ has a
function for comparing strings called <p_strcmpwhich compiles fine
and takes 2 <const void*as arguments. At run-time, for example, either
a <char*or even a <char**can be given as input and <void*will
handle them gracefully but I can not give a <void* to it as argument at
run-time. The input has to be of some type, to be useful to be processed
by the program.
Hence, <voidtype exists at compile-time for the kind of input we do not
know the type of yet but at run-time I can not make any input as of
<voidtype.

--
http://lispmachine.wordpress.com/
my email ID is at the above address

[Ulrich Eckhardt]

arnuld wrote:

int p_strcmp(const void *pv1, const void *pv2)
{
char * const * v1 = pv1;
char * const * v2 = pv2;
return strcmp(*v1, *v2);
}
I can use <char** v1 = pv1or <const char** v1 = pv1>

why use <char *const *v1 = pv1?

The const or volatile qualifier applies to the left, with the exception of
when it is at the leftmost part of a declaration, then it applies to the
right. For consistency, I would therefore suggest that you drop the habit
of writing things like this:

const char* p;

in favour of this:

char const* p;

Now, you can read this from right to left, i.e. 'p' is a pointer to a
constant 'char'. Getting back to the above example, you then have

const void *pv1

which I would rather write as

void const* pv1

Then, you simply replace the placeholder type 'void' with the real type of
the array (I guess it's about sorting with qsort()), and that is 'char*'
(note: without any const!):

char* const* pv1

This then reads 'pv1' is a pointer to a const pointer to a 'char'. This
basically means that you can not redirect the pointer to anywhere else,
i.e. an expression like this will fail to compile:

*pv1 = "foo";

Note that I personally would have added another const:

char const* const* pv1

This then also prevents accidental modification of the string it points to,
but for the general principle of converting between typed and typeless
pointers and back this isn't necessary.
BTW:
Some really paranoid people would even have added another const there:

char const* const* const pv1

I wouldn't do so here, but in general it helps in other situations like
this:

float const pi2 = acosf(0.0f);
... // LOTS of code
... // use pi2 here

The point is that from the declaration you already _know_ that pi2 isn't
changed anywhere in between. Not only that, even if you tried to change it
accidentally, you would get a compiler error. The problem with this is that
many C compilers don't allow you (according to C89) to define variables in
the middle of a block, only at the beginning.

cheers

Uli