Unable to sort dirent with qsort in C - 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

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 *.
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 be1
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.
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;
}
1Remember 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);