Thread: casting - pointer to pointer

[QUOTE=swoopy;744337]

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

[code]
Can't I just write:

i = (char *) p1;
j = (char *) p2;

Huh? since *(char **) == char *

> Can't I just write:

> i = (char *) p1;
> j = (char *) p2;

In a perfect world. Except, I have to assume that you are trying to sort a set of strings, in which case, that would be a misrepresentation of the data you are sorting.

The qsort function does not actually pass any type specifics around while it sorts. Meaning that the best qsort can do is pass some two parts of your array around for comparison based on the metrics of element size and array length you gave it; after all, since it has no idea what you are sorting, it can't pass you any type information.

So since you are sorting an array of strings, you have to represent the type yourself to make an accurate comparison:

Code:

int
elem_compare ( const void * n, const void * m )
{
   const char *const * elem1 = n;   /** I am really a pointer to a string **/
   const char *const * elem2 = m    /** I am really a pointer to a string **/
   return strcmp( *elem1, *elem2 ); /** compare ... **/
}

After you make a comparison, qsort moves some data around, and if it's not sorted yet, asks you to compare again, rinse and repeat. In the end, you get a sorted result according to the order your function established.

[QUOTE=terminator;744339]

Originally Posted by swoopy

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

[code]
Can't I just write:

i = (char *) p1;
j = (char *) p2;

Huh? since *(char **) == char *

[code]

Is (char **) casting equivalent to char **ptr declaration?

> Is (char **) casting equivalent to char **ptr declaration?

More or less. What vart said is a manner of understanding what casting will mean. If you feel the need to cast in C, it might mean that you should use a variable to represent the type instead. Sometimes this is overkill: casting from signed types to unsigned types should be fine, for example. By no means is there an excuse to rely on casting (see this thread) all the time, but you might encounter code that uses a cast, so you need to understand it.

Originally Posted by swoopy

Not quite, since the compare function is going to be passed offsets into this array:

Code:

  char *words[ ] = { "Then",   "he",   "shouted", "What", "I",
                    "didn't", "hear", "what",    "you",  "said" };

Reading from right to left, words is an array of pointers to char (char *words[]), and since arrays in C are passed as a pointer to the first element, that becomes char **words. So to get to a word in the array, you would need to dereference i and j.

Now if there were a way to pass compare() the addresses of array elements, then indeed what you propose would work. But in this case, somewhere in qsort the call to compare() becomes:

Code:

compare (words+offset1, words+offset2)

But the code compiles and gives the correct answer, even if I only use (char *) instead of (char **). Why's that?

I know VC++ will frequently fix very questionable code into what is most likely correct. But even at that, you are at the whim of what the compiler sees as "most likely correct." And even when it is kind enough to do this for you it does generate warnings about what you did, as well as what it decided was "most likely correct." Typically on a forum that revolves around technical assistance, I would suggest listening to the one's who seem to have the most technical assistance who are in agreement with one another.

I request anyone who doesn't understand what me, matsp, and many others have described to draw a simple picture. Draw squares representing blocks of data and arrows representing pointers. After you do this, I believe this will make more sense.

I think the reason why the OP is confused is that he/she is not aware that the calling function is actually passing pointers to pointers to char. That means that void * is interpreted by the called function as pointer to pointer to char. so the void type in this case means pointer_to_char.

I know this explanation is little precise, but it will hopefully make things clear. I hope so.