void qsort(void *base, size_t
   nmemb, size_t size,
   int (*compar)(const void *,
   const void *));

Since a void pointer is assignment-compatible with any data pointer, the first argument to qsort may be the address of any data type. When qsort is actually called, the pointer passed will be converted, as if by assignment, to a void pointer. (For most systems, such a cast results in no code being generated since all their pointer types have the same representation.)

qsort walks through an array, given the base address, element size, and element count, using some interesting casts. Note that base is not a const void * since qsort typically must modify some or all of the elements in the array passed. However, both arguments to compar are pointers to const void since the comparison function should not modify the data it's comparing.

The array of six ints has automatic storage duration. Historically, such arrays were not permitted to have initializer lists, although ANSI C now supports this capability. If your compiler complains, simply add the static keyword to the declaration.

After you define the comparison function cmpia, calling qsort is quite straightforward.

cmpia compares two ints whose addresses are passed. However, cmpia takes two void pointers, not int pointers. Since you cannot dereference a void pointer, a private copy of each argument is made in an int pointer. Note that without the const qualifier on the int pointers, your compiler may issue a warning since assigning a pointer to const to a pointer to non-const can lead to undefined behavior. Using two int pointers, you can easily compare the underlying ints and return the appropriate indicator, as shown.

I have developed the habit of using return 0 at the end of main, otherwise my compiler warns me I've failed to return a value from a non-void function. I find this message annoying so rather than ignore it, or worse yet, declare main (incorrectly) as a void function, I take the trouble of actually returning this exit status code even if it is never used. On some systems (VAX/VMS, for example), zero might not signify a success value, in which case you should either return the stdlib.h macro EXIT_SUCCESS or some other passive value.

The variables pi1 and pi2 are really unnecessary and can be replaced by a cast as follows (although you could argue the code is not as clear):

int cmpia(const void *pe1, const void *pe2)
{
   if (*(int *)pe1 < *(int *)pe2)
      return -1;
   else if (*(int *)pe1 == *(int *)pe2)
      return 0;
   else
      return 1;
}

int cmpia(const void *pe1, const void *pe2)
{
   return *(int *)pe1 - *(int *)pe2;
}

int cmpid(const void *pe1, const void *pe2)
{
   return *(int *)pe2 - *(int *)pe1;
}

descending integer order

array[0] = 25
array[1] = 24
array[2] = 22
array[3] =  3
array[4] =  3
array[5] = -5

Consider the case of an array of pointers to strings. You wish to search first on columns 1-4 then on 10-15. You could use strncmp for the comparisons for both keys, but you would need a global variable to notify strncmp where to begin comparing.

The code that lets your comparison function know where to start is relatively straightforward although I'm not sure this method is the best way to write an efficient multikey sort.

The comparison function must make a private copy of the converted input data before it performs the comparison. In no case is the function permitted to modify the elements to which its arguments point. (They have the const protection) And in any event, you don't want to modify them since you could not restore them later on.

If you could know the maximum length of the strings, you could allocate a local buffer (automatic if the code is to be reentrant, else static is OK) to store converted strings prior to comparison. If this size was not known, you could use strlen and malloc to allocate memory dynamically. However, allocating and freeing memory every time the comparison function is called could be quite expensive. And an even bigger issue is converting the same input strings many many times, since the conversion is done each time the comparison function is called.

A much better solution would be a two-dimensional array of pointers. The first pointer in each row would point to the original string, and the second would point to the converted string. Then you sort based on the second pointer finally traversing the array via the first pointer to get the sorted strings. That is, the comparison function is not involved in the string conversion at all.