casting - pointer to pointer

Code:

int main( )
{
  char *words[ ] = { "Then",   "he",   "shouted", "What", "I",
                    "didn't", "hear", "what",    "you",  "said" };
  int j = 0;
  int n = sizeof(words) / sizeof(char *);

  qsort( words, n, sizeof(char *), strptrcmp );

  for ( j = 0 ; j < n ; j++ )
    puts( words[j] );
}

int strptrcmp( const void *sp1, const void *sp2 )
// Compare two strings by reference.
{
  // qsort( ) passes a pointer to the pointer:
  // dereference it to pass a char * to strcmp.
  const char * s1 = *(char **)sp1;
  const char * s2 = *(char **)sp2;
  return strcmp( s1, s2 );
}

When I compile this code as

Code:

const char *s1 = *(char *) sp1;
const char *s2 = *(char *) sp2;

I get the compiler error...

initialization makes pointer from integer without a cast

What does it mean?

Really? I get no warning or error at all.

Code:

const char *s1 = *(char *) sp1;
const char *s2 = *(char *) sp2;

Yes, of course, you are dereferencing *(char *)sp1, which is a char - so the compiler can automatically convert that to a int, but it complains that you are trying to convert that integer to a pointer, because you should have a cast when you do that. In this case, you want two stars to make it pointer to a char *, so that you can dig out the original pointer to the word that is currently being sorted.

--
Mats

Oh, I didn't realize the big code and the small code was different. Of course the example snippet doesn't work. Dereferencing a char* gets you char, which is not char* (what you're trying to assign to).

Originally Posted by matsp

Code:

const char *s1 = *(char *) sp1;
const char *s2 = *(char *) sp2;

so the compiler can automatically convert that to a int, but it complains that you are trying to convert that integer to a pointer, because you should have a cast when you do that. In this case, you want two stars to make it pointer to a char *, so that you can dig out the original pointer to the word that is currently being sorted. --
Mats

Can you "simplify" a bit what you just said.
It's bouncing in my head...
Why would compiler convert it to an "int", where in the code am I converting integer to a pointer? Also, I am using casting.

> It's bouncing in my head...

Okay, let's rehash what we know:
void pointers can be assigned to any type.
To dereference a void pointer (*), you have to cast it to a type first.

in const char *s1 = *(char*) sp1;

(char*) is the cast, and to the left of that is the dereference. Since the result of dereferencing a char* is basically a integral type, the compiler complains as integers are not a pointer type.

There's a syntactical misunderstanding here that becomes a bigger problem.

Originally Posted by terminator

Can you "simplify" a bit what you just said.
It's bouncing in my head...
Why would compiler convert it to an "int", where in the code am I converting integer to a pointer? Also, I am using casting.

Right, if we break down your original statement:
const char *s1 = *(char *) sp1;
The orange is a variable declaration of a char pointer variable called s1.
The green star means "dereference the pointer" - which means "take whatever the pointer points at". The red says "Make this next thing into a char *". And the blue is your void pointer coming into this function.

So, the green bit says, "take whatever this points to", which the red bit says is a char pointer, so it becomes a char (becuase the green bit removes one pointer level). Then stuff that into a char pointer called s1.

The compiler will, as part of it's "helpfulness" convert your char to an integer - but then complain that it's not a pointer.

--
Mats

Originally Posted by citizen

> It's bouncing in my head...

Okay, let's rehash what we know:
void pointers can be assigned to any type.
To dereference a void pointer (*), you have to cast it to a type first.

in const char *s1 = *(char*) sp1;

(char*) is the cast, and to the left of that is the dereference. Since the result of dereferencing a char* is basically a integral type, the compiler complains as integers are not a pointer type.

There's a syntactical misunderstanding here that becomes a bigger problem.

Ahh... this guy is a good guy.
But wait... what's the meaning of "integral type"?

Also, dereferencing char* gives a char which is NOT a "string", but just a character, i.e. first character of a string. Right?

Integral type is all "integer types", anything that can hold whole numbers, such as "int", "short", "char", "long" and "enum types".

Non-integral types include "float", "double", any pointers, structs and unions (and classes in C++ of course).

--
Mats

Originally Posted by iMalc

Even Dave_Sinkula seems to have misunderstood this one, going by his first comment - Must be having an off day.

Probably.

Originally Posted by Dave_Sinkula

In C, there is probably little reason for any cast at all.

Code:

int strptrcmp( const void *sp1, const void *sp2 )
{
   const char *const * s1 = sp1;
   const char *const * s2 = sp2;
   return strcmp( *s1, *s2 );
}

dereferencing char* gives a char which is NOT a "string", but just a character, i.e. first character of a string. Right?

dereferencing char* gives a char which is NOT a "string", but just a character, i.e. first character of a string. Right?

Yes.

Originally Posted by terminator

dereferencing char* gives a char which is NOT a "string", but just a character, i.e. first character of a string. Right?

Yes - dereferencing ANY pointer gets you "one less star", so "char *" becomes "char", and "char ****" becomes a "char ***".

And yes, that'd be the first character of the string.

--
Mats

Code:

>int compare (const void *p1, const void *p2)
>{
>  const char *i;
>  const char *j;
>
>  i = *((char **)p1); //IF p1 & p2 are strings... what am I doing here?
>  j = *((char **)p2);

You could do the same thing without the casts like this:

Code:

int compare (const void *p1, const void *p2)
{
  const char **ptr1 = p1;
  const char **ptr2 = p2;
  const char *i;
  const char *j;

  i = *ptr1;
  j = *ptr2;

Originally Posted by swoopy

You could do the same thing without the casts like this:

Code:

int compare (const void *p1, const void *p2)
{
  const char **ptr1 = p1;
  const char **ptr2 = p2;
  const char *i;
  const char *j;

  i = *ptr1;
  j = *ptr2;

or even:
[code]

Code:

int compare (const void *p1, const void *p2)
{
  const char **ptr1 = p1;
  const char **ptr2 = p2;
  const char *i = *ptr1;
  const char *j = *ptr2;

--
Mats