Generic minimum function using function pointers in C

Question

I am trying to write a generic C function, that returns minimum of an array using function pointers.

The code is :

#include <stdio.h>

int min_index(void *arr, int size, int (*compare)(void *, void *))
{
    int i;
    int min = 0;

    for (i = 1; i < size; i++)
    {
        if (((*compare)(&arr[i], &arr[min])) < 0)
            min = i;
    }

    return min;
}

int comp_int(int *arr1, int *arr2)
{
    if (*arr1 < *arr2)
        return -1;
    else
        return 1;
}

int comp_char(char *arr1, char *arr2)
{
    if (*arr1 < *arr2)
        return -1;
    else
        return 1;
}

int main()
{
    int arr1[5] = {45, 56, 34, 23, 19};
    int index = min_index(arr1, 5, comp_int);  // calling min_index with integer array
    printf("Minimum value in the array is %d\n", arr1[index]);

    char arr2[5] = {'a', 'b', 'c', 'd', 'e'};
    int index2 = min_index(arr2, 5, comp_char); // calling min_index with char array
    printf("Minimum value in the array is %c\n", arr2[index2]);

    return 0;
}

1. This code worked for only char arrays. It did not work for int arrays.

2. I debugged the code. I found that, when I call min_index function with the integer array, only first value of arr is correct number, but remaining are some garbage values.

3. But, when I call min_index function with character array, all the values are correct. There are no garbage values in this case. I got correct output.

Question : Why does the code work for char arrays not for int arrays ?

Answer 1

It doesn't work because you need to cast the array itself on the original type and then access by index. Because C does not have template or a type check you will need to access the min_of() like functions by the size and the sign to get the correct conversion and sorting.

#include <stdio.h>

#define INVALID_VAL_TYPE  (int)(~0)

int new_umin_index(void * arr, int arr_len, int vsize){
    int i, index = 0;

    switch (vsize) {

        case sizeof(unsigned char):
            for (i = 0; i < arr_len; i++) {
                if ( ((unsigned char *)arr)[i] < ((unsigned char *)arr)[index] ){
                    index = i;
                }
            }
            break;

        case sizeof(unsigned):
            for (i = 0; i < arr_len; i++) {
                if ( ((unsigned *)arr)[i] < ((unsigned *)arr)[index] ){
                    index = i;
                }
            }
            break;
    
        default:
            index = INVALID_VAL_TYPE;
            break;
    }
    return index;
}

int new_imin_index(void * arr, int arr_len, int vsize){
    int i, index = 0;

    switch (vsize) {
        
        case sizeof(signed char):
            for (i = 0; i < arr_len; i++) {
                if ( ((signed char *)arr)[i] < ((signed char *)arr)[index] ){
                    index = i;
                }
            }
            break;

        case sizeof(int):
            for (i = 0; i < arr_len; i++) {
                if ( ((int *)arr)[i] < ((int *)arr)[index] ){
                    index = i;
                }
            }
            break;
    
        default:
            index = INVALID_VAL_TYPE;
            break;
    }
    return index;
}

int main(void) {

    int arr1[5] = {45, 56, 34, 23, 19};
    int i_min_index = new_imin_index(&arr1, 5, sizeof(int));
    printf("Minimum value in array<int> is %i \n", arr1[i_min_index]);

    char arr2[5] = {'b', 'a', 'c', 'd', 'e'};
    int c_min_index = new_umin_index(&arr2, 5, sizeof(char));
    printf("Minimum value in array<char> is %c \n", arr2[c_min_index]);

    return 0;
}

Answer 2

I came up with a solution, based on the comments of several users. This time I enabled all the warnings, and took care of every warning. The code is :

#include <stdio.h>
void* minimum(void *arr, int arr_count, size_t size, int (*compare)(const void *, const void *))
{
    void* pmin = arr;

    for(int i=1; i<arr_count; i++)
    {
        void* value = (char*)arr + i*size;  // size is the sizeof the type.

        if(((*compare)(value, pmin))<0)
        pmin = value;

    }

    return pmin;
    
}

int compare_ints(const void* a, const void* b)
{
    int arg1 = *(const int*)a;
    int arg2 = *(const int*)b;
 
    if (arg1 < arg2) return -1;
    if (arg1 > arg2) return 1;
    return 0;
}

int compare_chars(const void* a, const void* b)
{
    char arg1 = *(const char*)a;
    char arg2 = *(const char*)b;
 
    if (arg1 < arg2) return -1;
    if (arg1 > arg2) return 1;
    return 0;
}


int main()
{
    int arr1[5] = {45, 56, 34, 23, 19};
    int *pmin = minimum(arr1, 5,4, compare_ints); // In my system sizeof(int) is 4
    printf("Minimum value in the array is %d\n", *pmin);

    char arr2[5] = {'a', 'b', 'c', 'd', 'e'};
    char* pmin2 = minimum(arr2, 5,1, compare_chars); // sizeof(char) is 1
    printf("Minimum value in the array is %c\n",*pmin2 );

    return 0;
}

The output is (without any warnings) :

Minimum value in the array is 19
Minimum value in the array is a