«

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

On 8 Mar 2006 10:22:53 -0800, wrote:

>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.

--
Al Balmer
Sun City, AZ

wrote:
> 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[i]);
}

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?

In article < .com>,
<> wrote:
>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;
}

--
Rouben Rostamian

Al Balmer wrote:
> On 8 Mar 2006 10:22:53 -0800, wrote:
>
>> 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;

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.
--
Flash Gordon, living in interesting times.
Web site - http://home.flash-gordon.me.uk/
comp.lang.c posting guidelines and intro:
http://clc-wiki.net/wiki/Intro_to_clc

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: <private.php?do=newpm&u=>

<> wrote in message
news: oups.com...
> 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.
--
Buy my book 12 Common Atheist Arguments (refuted)
$1.25 download or $6.90 paper, available www.lulu.com

wrote:

> 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

"Default User" <> writes:

> wrote:
>
> > 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.

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).

, 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;
}

--
Pierre Maurette