Is there an easier way to work with pointers (sample code included)

[walter.preuninger]

Is there an easier way to code the cmp procedure without going thru all
the pointer manipulations?

#include <stdlib.h>
#include <string.h>

int cmp(const void *i, const void *j)
{
void *p1, *p2;
char **s1, **s2;
p1=(void *) i;
p2=(void *) j;
s1=(void *) p1;
s2=(void *) p2;
return strcmp(*s1,*s2);
}

int main(void)
{
char string0[]="zebra";
char string1[]="hello";
char string2[]="goodbye";

char *base[3];

base[0]=(char *)string0;
base[1]=(char *)string1;
base[2]=(char *)string2;

printf("\nbase[0] %s",base[0]);
printf("\nbase[1] %s",base[1]);
printf("\nbase[2] %s\n",base[2]);

qsort(&base,3,sizeof(base[0]),(void *)cmp);

printf("\nbase[0] %s",base[0]);
printf("\nbase[1] %s",base[1]);
printf("\nbase[2] %s\n",base[2]);
}


TIA,

Walter

 

[Al Balmer]

Is there an easier way to code the cmp procedure without going thru all
the pointer manipulations?

#include <stdlib.h>
#include <string.h>

int cmp(const void *i, const void *j)
{
void *p1, *p2;
char **s1, **s2;
p1=(void *) i;
p2=(void *) j;
s1=(void *) p1;
s2=(void *) p2;
return strcmp(*s1,*s2);
}

int cmp(const void *i, const void *j)
{
char *s1 = i;
char *s2 = p;

return strcmp(s1, s2);
}
Is that what you're trying to do?

BTW, please properly indent code you post. Your compiler may not care,
but people reading it do.

 

[Martin Ambuhl]

Is there an easier way to code the cmp procedure without going thru all
the pointer manipulations?

In addition to an excessive number of useless casts, you have left out a
key header.
Yes, you are trying too hard. Compare the code below to your code,
which follows it:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int compare_strings(const void *i, const void *j)
{
return strcmp(*(char **) i, *(char **) j);
}

void showstrs(size_t n, char *s[n])
{
size_t i;
for (i = 0; i < n; i++)
printf("s[%u] %s\n", (unsigned) i, s);
}

int main(void)
{
char *base[] = { "zebra", "hello", "goodbye" };
size_t n = sizeof base / sizeof *base;
showstrs(n, base);
putchar('\n');
qsort(base, n, sizeof *base, compare_strings);
showstrs(n, base);
return 0;
}

[output]
s[0] zebra
s[1] hello
s[2] goodbye

s[0] goodbye
s[1] hello
s[2] zebra


[OP's code]

#include <stdlib.h>
#include <string.h>

int cmp(const void *i, const void *j)
{
void *p1, *p2;
char **s1, **s2;
p1=(void *) i;
p2=(void *) j;
s1=(void *) p1;
s2=(void *) p2;
return strcmp(*s1,*s2);
}

int main(void)
{
char string0[]="zebra";
char string1[]="hello";
char string2[]="goodbye";

char *base[3];

base[0]=(char *)string0;
base[1]=(char *)string1;
base[2]=(char *)string2;

printf("\nbase[0] %s",base[0]);
printf("\nbase[1] %s",base[1]);
printf("\nbase[2] %s\n",base[2]);

qsort(&base,3,sizeof(base[0]),(void *)cmp);

printf("\nbase[0] %s",base[0]);
printf("\nbase[1] %s",base[1]);
printf("\nbase[2] %s\n",base[2]);
}


TIA,

^^^
Are you a bill-collector or a script-kiddie?

 

[Rouben Rostamian]

Is there an easier way to code the cmp procedure without going thru all
the pointer manipulations?

#include <stdlib.h>
#include <string.h>

int cmp(const void *i, const void *j)
{
void *p1, *p2;
char **s1, **s2;
p1=(void *) i;
p2=(void *) j;
s1=(void *) p1;
s2=(void *) p2;
return strcmp(*s1,*s2);
}

[... the rest of the code snipped ...]

As a rule, the use of casts in a code is an indication that
something is wrong. There are exceptions to this rule, but in
general a cast should raise a red flag in your mind. Here is
a modified version of your code without casts. It is shorte
and should be easier to understand and debug:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int cmp(const void *a, const void *b)
{
char * const *aa = a;
char * const *bb = b;
return strcmp(*aa, *bb);
}

int main(void)
{
char string0[] = "zebra";
char string1[] = "hello";
char string2[] = "goodbye";
char *base[3];

base[0] = string0;
base[1] = string1;
base[2] = string2;

qsort(base, (sizeof base)/(sizeof base[0]), sizeof base[0], cmp);

printf("base[0] = %s\n",base[0]);
printf("base[1] = %s\n",base[1]);
printf("base[2] = %s\n",base[2]);

return EXIT_SUCCESS;
}

 

[Flash Gordon]

int cmp(const void *i, const void *j)
{
char *s1 = i;
char *s2 = p;

Don't you mean:
const char *s1 = i;
const char *s2 = j;

return strcmp(s1, s2);
}
Is that what you're trying to do?

BTW, please properly indent code you post. Your compiler may not care,
but people reading it do.

Definitely.

 

[Kenneth Brody]

Al Balmer wrote:
[...qsort compare function on string array...]

int cmp(const void *i, const void *j)
{
char *s1 = i;
char *s2 = p;

return strcmp(s1, s2);
}

[...]

Any reason you can't simply do:

int cmp(const void *i, const void *j)
{
return strcmp(i,j);
}

--
+-------------------------+--------------------+-----------------------------+
| Kenneth J. Brody | www.hvcomputer.com | |
| kenbrody/at\spamcop.net | www.fptech.com | #include <std_disclaimer.h> |
+-------------------------+--------------------+-----------------------------+
Don't e-mail me at: <mailto:[email protected]>

 

[Malcolm]

Is there an easier way to code the cmp procedure without going thru all
the pointer manipulations?

#include <stdlib.h>
#include <string.h>

int cmp(const void *i, const void *j)
{
void *p1, *p2;
char **s1, **s2;
p1=(void *) i;
p2=(void *) j;
s1=(void *) p1;
s2=(void *) p2;
return strcmp(*s1,*s2);
}

int main(void)
{
char string0[]="zebra";
char string1[]="hello";
char string2[]="goodbye";

char *base[3];

base[0]=(char *)string0;
base[1]=(char *)string1;
base[2]=(char *)string2;

printf("\nbase[0] %s",base[0]);
printf("\nbase[1] %s",base[1]);
printf("\nbase[2] %s\n",base[2]);

qsort(&base,3,sizeof(base[0]),(void *)cmp);

printf("\nbase[0] %s",base[0]);
printf("\nbase[1] %s",base[1]);
printf("\nbase[2] %s\n",base[2]);
}


TIA,

Walter

Sorting a plain array of strings is usually pretty pointless.
Do something like this

typedef struct
{
char name[64];
char *description;
/* probably lots of other data associated with animals here */
} ANIMAL;

int cmp(const void *e1, const void *e2)
{
const ANIMAL *a1 = e1;
const ANIMAL *a2 = e2;

return strcmp(al->name, a2->name);
}

That's not too burdensome.

 

[Default User]

Is there an easier way to code the cmp procedure without going thru
all the pointer manipulations?

#include <stdlib.h>
#include <string.h>

int cmp(const void *i, const void *j)
{
void *p1, *p2;
char **s1, **s2;
p1=(void *) i;
p2=(void *) j;
s1=(void *) p1;
s2=(void *) p2;
return strcmp(*s1,*s2);
}

In addition to what all the others have said, you should almost NEVER
cast away const from a pointer. That's a major indicator that there's a
design flaw.



Brian

 

[Micah Cowan]

In addition to what all the others have said, you should almost NEVER
cast away const from a pointer. That's a major indicator that there's a
design flaw.

The exception would be when you're implementing something like
strchr(); where you want your parameter list to indicate a guarantee
that you won't change the string, but you don't want to force the
caller to make that same guarantee (or do the cast there).

 

[Pierre Maurette]

(e-mail address removed), le 08/03/2006 a écrit :

Is there an easier way to code the cmp procedure without going thru all
the pointer manipulations?

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define AFFICHE printf("\nbase[0] %s""\nbase[1] %s""\nbase[2] %s\n",\
base[0],\
base[1],\
base[2])

typedef char* chaine;
typedef int(*f_comp_t)(const void*, const void*);


int cmp_chaine(const chaine* i, const chaine* j)
{
return strcmp(*i,*j);
}

int main(void)
{
char string0[]="zebra", string1[]="hello", string2[]="goodbye";
chaine base[] = {string0, string1, string2};
AFFICHE;
qsort(base,3,sizeof(chaine),(f_comp_t)cmp_chaine);
AFFICHE;
return 0;
}

Or:

/* .... */

int main(void)
{
char string0[]="zebra", string1[]="hello", string2[]="goodbye";
chaine base[] = {string0, string1, string2};
f_comp_t cmp = (f_comp_t)cmp_chaine;
AFFICHE;
qsort(base,3,sizeof(chaine),cmp);
AFFICHE;
return 0;
}

 

[Al Balmer]

Don't you mean:
const char *s1 = i;
const char *s2 = j;


Definitely.

 

[Default User]

The exception would be when you're implementing something like
strchr(); where you want your parameter list to indicate a guarantee
that you won't change the string, but you don't want to force the
caller to make that same guarantee (or do the cast there).

I guess I'm not following. You can always pass a non-const pointer
through a const parameter. The caller wouldn't need to cast, nor would
the implementer.

In the previous code, the OP had const parameters and then blithely
cast the const away inside the function.



Brian

 

[Richard Heathfield]

Default User said:

I guess I'm not following. You can always pass a non-const pointer
through a const parameter. The caller wouldn't need to cast, nor would
the implementer.

No, think about strchr for a second (and don't worry too much about whether
I've got the implementation right - focus on the types):

char *strchr(const char *s, int ch)
{
char *p = (char *)s; /* either you cast it here... */
while(*p != '\0' && *p != ch)
{
++p;
}
if(*p == '\0')
{
p = NULL;
}
return p;
}

char *strchr(const char *s, int ch)
{
while(*s != '\0' && *s != ch)
{
++s;
}
if(*s == '\0')
{
s = NULL;
}
return (char *)s; /*... or you cast it here */
}

In the previous code, the OP had const parameters and then blithely
cast the const away inside the function.

Sure, and your point was perfectly valid. I think we're moving on a bit from
there now.

 

[pete]

Is there an easier way to code the cmp procedure without going thru all
the pointer manipulations?

#include <stdlib.h>
#include <string.h>

int cmp(const void *i, const void *j)
{
void *p1, *p2;
char **s1, **s2;
p1=(void *) i;
p2=(void *) j;
s1=(void *) p1;
s2=(void *) p2;
return strcmp(*s1,*s2);
}

int main(void)
{
char string0[]="zebra";
char string1[]="hello";
char string2[]="goodbye";

char *base[3];

base[0]=(char *)string0;
base[1]=(char *)string1;
base[2]=(char *)string2;

printf("\nbase[0] %s",base[0]);
printf("\nbase[1] %s",base[1]);
printf("\nbase[2] %s\n",base[2]);

qsort(&base,3,sizeof(base[0]),(void *)cmp);

printf("\nbase[0] %s",base[0]);
printf("\nbase[1] %s",base[1]);
printf("\nbase[2] %s\n",base[2]);
}

/* BEGIN new.c */

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

int cmp(const void *i, const void *j)
{
return strcmp(i, j);
}

int main(void)
{
char string0[] = "zebra";
char string1[] = "hello";
char string2[] = "goodbye";
char *base[3];

base[0] = string0;
base[1] = string1;
base[2] = string2;
printf("base[0] %s\n", base[0]);
printf("base[1] %s\n", base[1]);
printf("base[2] %s\n", base[2]);
putchar('\n');
qsort(base, sizeof base / sizeof*base, sizeof*base, cmp);
printf("base[0] %s\n",base[0]);
printf("base[1] %s\n",base[1]);
printf("base[2] %s\n",base[2]);
return 0;
}

/* END new.c */

 

[August Karlstrom]

Is there an easier way to code the cmp procedure without going thru all
the pointer manipulations?

#include <stdlib.h>
#include <string.h>

int cmp(const void *i, const void *j)
{
void *p1, *p2;
char **s1, **s2;
p1=(void *) i;
p2=(void *) j;
s1=(void *) p1;
s2=(void *) p2;
return strcmp(*s1,*s2);
}

int main(void)
{
char string0[]="zebra";
char string1[]="hello";
char string2[]="goodbye";

char *base[3];

base[0]=(char *)string0;
base[1]=(char *)string1;
base[2]=(char *)string2;

printf("\nbase[0] %s",base[0]);
printf("\nbase[1] %s",base[1]);
printf("\nbase[2] %s\n",base[2]);

qsort(&base,3,sizeof(base[0]),(void *)cmp);

printf("\nbase[0] %s",base[0]);
printf("\nbase[1] %s",base[1]);
printf("\nbase[2] %s\n",base[2]);
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define COUNT 3
#define MAX_LEN 32

char strings[COUNT][MAX_LEN] = {"zebra", "hello", "goodbye"};

void show(char strings[][MAX_LEN])
{
int k;

for (k = 0; k < COUNT; k++) printf("%s, ", strings[k]);
printf("\n");
}


int main(void)
{
show(strings);
qsort(strings, COUNT, MAX_LEN,
(int (*)(const void *, const void *)) strncmp);
show(strings);
return 0;
}


August

 

[Peter Nilsson]

/* BEGIN new.c */

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

int cmp(const void *i, const void *j)
{
return strcmp(i, j);
}

int main(void)
{
char string0[] = "zebra";
char string1[] = "hello";
char string2[] = "goodbye";
char *base[3];

base[0] = string0;
base[1] = string1;
base[2] = string2;
printf("base[0] %s\n", base[0]);
printf("base[1] %s\n", base[1]);
printf("base[2] %s\n", base[2]);
putchar('\n');
qsort(base, sizeof base / sizeof*base, sizeof*base, cmp);
printf("base[0] %s\n",base[0]);
printf("base[1] %s\n",base[1]);
printf("base[2] %s\n",base[2]);
return 0;
}

/* END new.c */

One thing that AFAIK hasn't been pointed out in the thread is there is
no language guarantee that this will sort the strings into the order:

goodbye
hello
zebra

 

[Default User]

Default User said:

return (char *)s; /*... or you cast it here */

Bah, I didn't think it through to the return. Never mind.




Brian

 

[Malcolm]

No, think about strchr for a second (and don't worry too much about
whether
I've got the implementation right - focus on the types):

char *strchr(const char *s, int ch)

This is where the hacked in status of const as a late addition to the
language beocmes apparent.
const should taint everything it points to, and all pointers derived from
it. But that would be a major reengineering exercise.

 

[Jordan Abel]

This is where the hacked in status of const as a late addition to the
language beocmes apparent.
const should taint everything it points to, and all pointers derived from
it. But that would be a major reengineering exercise.

typeof would allow this, after a fashion:

#define strchr(x,c) (typeof x)strchr(x,c)

 

[David Holland]

> [...]
> int cmp(const void *i, const void *j)
> {
> return strcmp(i, j);
> }
>
> [...]
> char *base[3];
> base[0] = string0;
> base[1] = string1;
> base[2] = string2;
> [...]
> qsort(base, sizeof base / sizeof*base, sizeof*base, cmp);

Several people have posted code like this now, all apparently without
noticing that it's wrong.

base is an array of pointers to char. This is passed to qsort. qsort
calls cmp with two pointers, each of which points *to an element of
the array*.

Those void *'s in the argument of cmp are "really" char **, not char *,
and passing them to strcmp produces undefined behavior.

It so happens that you (and the OP) have laid out the program so that
on most platforms strcmp will reach a zero byte somewhere before
faulting, and the conventional layout of automatic storage is such
that strcmp interpreting the addresses as strings will generate the
expected output sort order, so just running the program once to check
it is misleading.

cmp needs to be

int cmp(const void *i0, const void *j0) {
const char *const *i = i0;
const char *const *j = j0;
return strcmp(*i, *j);
}

HTH.