Unable to sort dirent with qsort in C

Question

I am having trouble sorting a dirent struct in C. I have tried everything and cannot get the values of my struct array to appear in my comparison. My code looks like this:

void printSortedNames(){

    struct dirent **file_list = (dirent**)malloc(5 * sizeof(dirent*));

    int i = 0;
    for (i = 0; i < directory_size; ++i){
        file_list[i] = (dirent*)malloc(50 * sizeof(dirent));
    }

    DIR *dir;
    struct dirent *sd;

    dir = opendir(".");

    if (dir == NULL){
        printf("Error! unable to open directory.\n");
        exit(1);
    }

    int count = 0;
    while ((sd = readdir(dir)) != NULL){
        file_list[count] = sd;
        printf("%s\n", file_list[count]->d_name);
        ++count;
    }

    size_t file_list_size = sizeof(&file_list) / sizeof(struct dirent);

    qsort(file_list, file_list_size, sizeof(struct dirent), sizeCompare);
}

I have created a simple function sizeCompare to show that my function is working but I get null values. My function looks like:

int sizeCompare(const void* a, const void* b){

    printf("%s\n", ((const struct dirent*)a)->d_name);
}

Can someone explain to me why my sizeCompare is not retrieve the array values correctly?

UPDATE: I have tried playing around with the size in the qsort and my value as a result was no longer null. the following line gives me an output:

qsort(file_list, 1000, sizeof(struct dirent), sizeCompare);

Obviously 1000 is not a good solution. Does anybody know the correct size for an array like this?

UPDATE 2: sizeCompare function only takes the first parameter and the second one is null.

int sizeCompare(const void* a, const void* b){

    const struct dirent *first_dirent = *(const struct dirent **) a;
    const struct dirent *second_dirent = *(const struct dirent **) b;
    .......
    //first one works but second one is NULL
}

Answer 1

1. In the comparison function you need to dereference the pointers by first casting to struct dirent **, like this

   const struct dirent *first_dirent = *(const struct dirent **) first_parameter;
   

   this is because the address of each element is passed and since elements are pointers, the pointers passed to the funcion are pointers to pointers. Their void * addresses are the same, but you can't cast const struct dirent ** directly to const struct dirent *.

2. You have another important problem this,

   file_list_size = sizeof(&file_list) / sizeof(struct dirent);
   

   is wrong, try to print the value and see and it should be¹

   file_list_size = count;
   

   because your code computes the size of a pointer divided by the size of struct dirent which is probably resulting in 0, read about the sizeof operator, it's result depends on the passed argument. When it's a variable, the size of the type is the result, when the variable is an array it's the size of the array.

   Since file_list is a pointer to pointer, i.e. Not an array, then the result of

   file_list_size = sizeof(&file_list) / sizeof(struct dirent);
   

   is not what you think it is or what it should actually be.

3. There is no correct size, perhaps you should count the entries first and predict a value for the first malloc() in your code. Or use realloc() and dynamically count the entries and allocate the poitners simultaneously.

Also:

• Your code leaks memory as pointed out by @user3629249 in this comment

• You don't need to cast the return value from malloc()

• Try not to mix code with declarations, it makes it hard to track variables and their scope.

• You allocate space for 5 struct dirent * pointers but you never check for the count variable whether it reached or went beyond that value. That could lead to undefined behavior.

• Your code also leaks memory because you never call closedir().

Here is an example of alphabetically sorting the entries

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <dirent.h>

int
compareSize(const void *const A, const void *const B)
{
    return strcmp((*(struct dirent **) A)->d_name, (*(struct dirent **) B)->d_name);
}

void printSortedNames(const char *const path)
{
    int count;
    DIR *dir;
    struct dirent **list;
    struct dirent *entry;

    dir = opendir(path);
    if (dir == NULL)
    {
        fprintf(stderr, "cannot open `%s'\n", path);
        return;
    }

    /* First determine the number of entries */
    count = 0;
    while ((entry = readdir(dir)) != NULL)
        ++count;
    /* Allocate enough space */
    list = malloc(count * sizeof(*list));
    if (list == NULL)
    {
        closedir(dir);
        fprintf(stderr, "memory exhausted.\n");
        return;
    }
    /* You don't need to allocate the list elements
     * you can just store pointers to them in the
     * pointer array `list'
     */
    rewinddir(dir); /* reset position */
    /* Save the pointers allocated by `opendir()' */
    count = 0;
    while ((entry = readdir(dir)) != NULL)
        list[count++] = entry;
    /* Call `qsort()', read about the `sizeof' operator */
    qsort(list, count, sizeof(*list), compareSize);
    /* Print the sorted entries now */
    for (int index = 0 ; index < count ; ++index)
        fprintf(stderr, "%s\n", list[index]->d_name);
    closedir(dir);
}

int
main(void)
{
    printSortedNames("/home/iharob");
    return 0;
}

---

¹_{Remember to limit the value of count to the maximum number of pointers you allocated space for.}

Answer 2

Your sizeCompare function is not returning anything. You need to implement is such that it returns -1 when a < b, 0 when a = b and 1 when a > b.

int sizeCompare(const void* a, const void* b) {
    // The implementation should return something
}

Also, you're calculating the file_list_size incorrectly. Can't you pass count as the second argument instead?

qsort(file_list, count, sizeof(struct dirent), sizeCompare);