Question

If I have a sorting algorithm, and I want to sort by some field of a structure. I’m basically looking for the possibility of a parameter (sortBy in this case) being able to determine whether fieldOne would be compared, or fieldTwo–without continually checking for the correct field to use.

void func(SomeType *arr, int length, int sortBy) {
    int i;
    for(int i = 0; i < length, i++) {
        if(sortBy == 1) {
            doSomethingTo(arr[i].fieldOne);
        }
        else if(sortBy == 2) {
            doSomethingTo(arr[i].fieldTwo);
        }
        // etc
    }
}

Answer 1

You can observe what the Standard C qsort() does. It sorts any array of any type, using a comparator function:

void qsort(void *base, size_t nel, size_t width,
           int (*compar)(const void *v1, const void *v2));

The comparator function returns a negative value if v1 should sort before v2, a positive value if it should sort after, and zero if the values are equal under this sorting criterion. Note that it is necessary to compare two values; it is not sufficient to compare one value with its own navel.

In your example, you are sorting a fixed type, it seems. You could use qsort(), or you can borrow the comparator type idea, and adapt it to your sort:

void func(SomeType *arr, int length, int (*comparator)(const SomeType *v1, const SomeType *v2))
{
    ...
    int cmp = comparator(&arr[i], &arr[j]);
    ...
}

Your comparator might be:

static int compare_fieldOne(const SomeType *v1, const SomeType *v2)
{
    if (v1->fieldOne < v2->fieldOne)
        return -1;
    else if (v1->fieldOne > v2->fieldOne)
        return +1;
    return 0;
}

If you need to do more comparisons, you can add extra pairs of tests after the the else if clause, leaving the equality case to the end.