An interesting problem of qsort()

As you know, the qsort has the signature:
void qsort ( void * base, size_t num, size_t size, int ( * comparator ) ( const void *, const void * ) );

The following code is from http://www.cplusplus.com/reference/c...lib/qsort.html
Is it wrong? Seems

Code:

qsort (values, 6, sizeof(int), compare);

should be

Code:

qsort (values, 6, sizeof(int), &compare);

Code:

/* qsort example */
#include <stdio.h>
#include <stdlib.h>

int values[] = { 40, 10, 100, 90, 20, 25 };

int compare (const void * a, const void * b)
{
  return ( *(int*)a - *(int*)b );
}

int main ()
{
  int n;
  qsort (values, 6, sizeof(int), compare);
  for (n=0; n<6; n++)
     printf ("%d ",values[n]);
  return 0;
}

It is not wrong. When passed as an argument, a function is converted to a function pointer.

In the above context, "compare" is the address of the function, you do not therefore need to prefix that with '&'.

Is this C++?
If so, you should consider using std::sort() instead of the old qsort() function.

Originally Posted by meili100

Code:

int compare (const void * a, const void * b)
{
  return ( *(int*)a - *(int*)b );
}

Sidebar: the comparison function has issues with integer over/underflow and is not a good example of well-defined behavior.

the name of a function, like the name of an array, can be assigned to a pointer of the same type. No need for the address-of operator.

. . . but unlike arrays, you can use either way with function pointers. And there are two ways to call function pointers as well.

Code:

#include <iostream>

void func() {
    std::cout << "func()\n";
}

int main() {
    void (*f)();

    f = func;
    f = &func;

    f();
    (*f)();

    return 0;
}

The reason for this is that some people thought one way was better, and others the other way. Since both arguments made sense, ANSI incorporated both into C. And C++ got it from there.

(All of these arguments are from memory, they may be wrong . . . .)

The argument for func: when you call a function you use parentheses, so leaving off the parentheses is like leaving off the [] array index operators: you should get a pointer. A similar argument applies for func().

The argument for &func: func is a single object. With arrays, it's true, you can use "array" to get a pointer; but all single objects, be they structures or numbers, you need to use an & to get the address. A similar argument applies for (*func)().

For more detailed information, see: http://www.newty.de/fpt/index.html
(I know it says &func is better than func, but I don't think that's so.)