void pointer arithmetic

[Alex Fraser]

From searching Google Groups, I understand that void pointer arithmetic is a
constraint violation, which is understandable. However, generic functions
like qsort() and bsearch() must in essence do exactly this, and similarly
generic functions seem to have useful applications.

In a few posts I read, it was suggested to avoid void pointer arithmetic by
casting to a char pointer, and performing arithmetic on that (in multiples
of sizeof(original _type)). Thus the pointer is cast through the sequence
original_type* -> void* -> char* -> void* -> original_type*.

I am quite sure this would work on many implementations (where the casts are
no-ops), but the threads I saw containing the above suggestion did not make
clear whether or not it was undefined (or implementation defined)
behaviour - is it? If so, is there any way to achieve the desired effect
while strictly conforming to the standards?

TIA,
Alex

[Hallvard B Furuseth]

Jeremy Yallop wrote:

I think this needs to be something like:

int compare(const void *s1, const void *s2)
{
return strcmp(*(char **)s1 + OFFSET, *(char **)s2 + OFFSET);
}

Or

int compare(const void *s1, const void *s2)
{
return strcmp(*(char *const *)s1 + OFFSET,
*(char *const *)s2 + OFFSET);
}

If you want to avoid some compilers' warnings about casting
away 'const'.

--
Hallvard

[Jeremy Yallop]

Hallvard B Furuseth wrote:

Jeremy Yallop wrote:

I think this needs to be something like:

int compare(const void *s1, const void *s2)
{
return strcmp(*(char **)s1 + OFFSET, *(char **)s2 + OFFSET);
}
Or

int compare(const void *s1, const void *s2)
{
return strcmp(*(char *const *)s1 + OFFSET,
*(char *const *)s2 + OFFSET);
}

Sure. I think that counts as "something like". In this case I find
that the extra "const" makes the code more difficult to read. I might
add it if using extra local variables instead of casting.
If you want to avoid some compilers' warnings about casting
away 'const'.

There should be a way to turn that warning off without changing the
code. Casting away const is sometimes necessary (e.g. to implement a
function with an interface like strstr()). (Okay, not strictly
/necessary/ - you can use memcpy() instead, for example - but
"necessary in sane code").

Jeremy.

[Jeremy Yallop]

CBFalconer wrote:

Jeremy Yallop wrote:

Hallvard B Furuseth wrote:

> ... snip ... >
> int compare(const void *s1, const void *s2)
> {
> return strcmp(*(char *const *)s1 + OFFSET,
> *(char *const *)s2 + OFFSET);
> }

Sure. I think that counts as "something like". In this case I
find that the extra "const" makes the code more difficult to read.
I might add it if using extra local variables instead of casting.

> If you want to avoid some compilers' warnings about casting
> away 'const'.

There should be a way to turn that warning off without changing
the code. Casting away const is sometimes necessary (e.g. to
implement a function with an interface like strstr()). (Okay,
not strictly /necessary/ - you can use memcpy() instead, for
example - but "necessary in sane code").

/* invalid for strlen(s) < OFFSET */
int compare(const void *s1, const void *s2)
{
const char *p1 = s1;
const char *p2 = s2;

return strcmp(p1 + OFFSET, p2 + OFFSET);
}

No, this is wrong. You need an extra level of indirection. The
pointers passed to the comparison function are pointers to the objects
in the array. That is, they're pointers to pointers to char disguised
as pointers to (const) void. If you want to write the comparison
function in this way you can write:

int compare(const void *s1, const void *s2)
{
const char *const *p1 = s1;
const char *const *p2 = s2;

return strcmp(*p1 + OFFSET, *p2 + OFFSET);
}

(with more or fewer "const"s according to taste).

Jeremy.