Thread: casting - pointer to pointer

Originally Posted by zacs7

If you fully understand pointers, understanding pointers-to-pointers should be no problem.

Pointers only hold an address to something else, think of it like man pointing to something. Consider the following, let man = pointer.

Code:

[man 0] -> [man 1] -> [man 2] -> [the man you want]

You want to remember where [the man you want] is,
* so you tell man 2 to remember where he is,
* you tell man 1 to remember where man 2 is
* you tell man 0 to remember where man 1 is

If you want to find [the man you want] you can either,
1. ask man 0 where man 1 is (see 2.)
2. ask man 1 where man 2 is (see 3.)
3. ask man 2 where [the man you want] is.

You can of course skip to 2 or 3 or even straight to the man.

I hope my corny example made it clear

I already know all of the above but, what's the use of (char **)???
p1 & p2 are pointers to "VOID"...
Do we have to use (char **) casting for all the "VOID" argument types? or does it depend on the arguments passed to the function?

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

Originally Posted by Elysia

Void* is a special type of pointer that can hold an address to anything. In our examples, we just converted a const char** pointer into void*. So when we later want to get it back, we cast it to char** and then dereference to get char*.

Anyone can draw a diagram of this?

From what I understand, "void *" is just a generalized function argument, it can take any type of pointer.

Also, in qsort... why is it written only "compare"(the fucntion whose code I posted above) instead of compare(arguments)...

Code:

qsort((void *)words, wordCount, sizeof(char *), compare);

Originally Posted by Elysia

That is exactly what it is. A generic type of pointer that can hold anything. You can't dereference void, for example, because it can hold anything. So the compiler doesn't even know what it is.

Is this how it works???

Code:

char **c;
char **d;
*c[0] = "I am a string";
*d[0] = "I am also a string";

Now, we pass these two char** as arguments of function:

int compare(const void *p, const void *q)
{
const char * c = *((char **) p);
const char * j = *((char **) q);

do stuff with above strings....
}

Originally Posted by iMalc

Nope, the second one is completely wrong. You can't subtract the *'s. This function is obviously being used as an argument to qsort which is to sort an array of char*'s a.k.a strings.

Original code: The *'s in the cast itself don't do anything besides tell the compiler what type of thing the void pointer is supposed to be. This doesn't generate any code whatsoever. The outer star on the left actually tells the compiler to dereference the thing on the right. That means asking the compiler to generate code that fetches what is at some memory address, and viola you have correct code. There is no simpler way to do this. It must cast to a char**!

Your incorrect code: The single char* cast tells the compiler (incorrectly) that the data is already a char pointer. This in itself generates no code at all. It does not look up and memory address to get the correct pointer value, and will produce non-working code.

Even Dave_Sinkula seems to have misunderstood this one, going by his first comment - Must be having an off day.
King Mir has a good explanation.

OK, I think I see now... I would have expected a void** in that case; but if it's a function pointer for qsort(), I guess you'd have to do it like that.

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?