This code defines a function to sort and overwrite a...

September 3, 2025 at 10:48 PM

// Comparator per qsort
int cmp(const void *a, const void *b) {
  const char *pa = *(const char **)a;
  const char *pb = *(const char **)b;
  return strcmp(pa, pb);
}

// Funzione per ordinare la base di dati
void ordinaDatabase() {
  // Accedo alla base di dati in modalita lettura
  FILE *file = fopen(DataBase, "r");
  if (!file) {
    perror("Errore apertura database");
    return;
  }

  char *righe[1024];
  int count = 0;
  char buffer[512];

  while (fgets(buffer, sizeof(buffer), file) && count < 1024) {
    righe[count] = strdup(buffer);
    if (!righe[count]) {
      perror("malloc fallita");
      fclose(file);
      return;
    }
    count++;
  }
  fclose(file);

  qsort(righe, count, sizeof(char *), cmp);

  file = fopen(DataBase, "w");
  if (!file) {
    perror("Errore scrittura database");
    for (int i = 0; i < count; i++) free(righe[i]);
    return;
  }

  for (int i = 0; i < count; i++) {
    fputs(righe[i], file);
    free(righe[i]);
  }
  fclose(file);

  printf("Database ordinato.\n");
}

This code defines a function to sort and overwrite a database file (assumed to be a text file) composed of multiple lines of data. Here's a detailed explanation of what it does:

Key Operations

Comparator Function (cmp):
- cmp is a comparator used by the qsort function. It defines how two lines (pointers to strings) are compared.
- The function treats its arguments as const void *, but internally casts them to const char ** (pointers to pointers to char) and dereferences them.
- Finally, it uses strcmp to compare the two strings lexicographically (alphabetical order).
- This function will be used to sort the lines by their lexicographical order.
Reading the Database File:
- The function ordinaDatabase opens the file named by the DataBase constant in read mode ("r"). If the file fails to open, it prints an error message and exits early.
- It reads the contents of the file line by line using fgets and stores each line dynamically in a string array righe (of size 1024, maximum supported lines).
- Lines are duplicated with strdup, which allocates memory to store a copy of each line.
- If memory allocation fails, it cleans up and exits.
Sorting the Lines:
- The qsort function is used to sort the array of strings (righe) using the cmp comparator function. The sorting is done in-place.
Writing the Sorted Data Back:
- Once sorting is complete, the function reopens the file in write mode ("w") to overwrite its contents.
- Each line from the sorted array is written to the file using fputs.
- The dynamically allocated memory for each line is freed after writing it to the file.
Cleanup:
- After the lines are written, the file is closed, and all allocated memory for the lines is freed.
- A success message ("Database ordinato.", or "Database sorted.") is printed to the console.

Summary

Input: A file named DataBase containing up to 1024 lines of text.
Output: The same file with its lines sorted alphabetically.
Key Functions: File I/O (fopen, fgets, fputs, fclose), dynamic memory functions (strdup, free), sorting (qsort), error handling with perror.

Potential Risks and Assumptions:

Memory Constraints:
- Each line is stored in memory using strdup, and the array righe holds up to 1024 pointers. This may exhaust memory if the file is large.
File Size:
- The function assumes a hard-coded maximum of 1024 lines. It won't handle files with more lines correctly.
Error Handling:
- Errors during file reading, writing, or memory allocation are handled with printed error messages, but no recovery is possible.
File Locking:
- There is no explicit file locking mechanism, so the file could be modified by another process during execution.

Overall, the function reads, sorts, and overwrites the database file with lines in alphabetical order.

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr