Realloc no está redimensionando la matriz de punteros

Sigo pasando y devolviendo el dirs_later_array. Cuando llego a “new_size = …” en el bloque else, termino con new_size de 2 la segunda vez. Hasta ahora tan bueno. Pero cuando hago un realloc

dirs_later_array = realloc(dirs_later_array, new_size * sizeof(struct dirs_later*)); 

El tamaño de permanece en 4, el tamaño del puntero, para dirs_later_array. Puedo almacenar con éxito en dirs_later_array [1] pero ese valor se sigue sobrescribiendo la próxima vez que entre en la función.

 struct dirs_later ** add_struct (const char * findme, struct dirent * dptr,
         struct stat * this_lstat, char * relative_path, const char * type_str,
         struct dirs_later ** dirs_later_array) {

     struct dirs_later * new_dir = malloc (sizeof (struct dirs_later));
     check_realloc_dirs_error (new_dir);

     if (strcmp (dptr-> d_name, ".")) {// Dir y no el mismo directorio
         // Copia la ruta relativa a la estructura.
         char * relative_path2;
         relative_path2 = malloc (strlen (relative_path) + 1);
         check_realloc_error (relative_path2);
         strcpy (relative_path2, relative_path);

         // if (strlen (relative_path)> 0)
         // relative_path2 [strlen (relative_path) - 1] = '\ 0';

         if (NULL! = new_dir) {
             new_dir-> findme = findme;
             nuevo_dir-> dptr = dptr;
             new_dir-> st_mode = this_lstat-> st_mode;
             new_dir-> relative_path = relative_path2;
             new_dir-> type_str = type_str;
         }
         int new_size = 0;
         / *
          // Comprueba si este es el primer elemento en la estructura.
          if (sizeof (dirs_later_array) / sizeof (struct dirs_later *) == 1) {
          new_size = 1;
          }
          * /
         if (dirs_later_array == NULL) {
             dirs_later_array = malloc (sizeof (struct dirs_later *));  // Almacena las estructuras del directorio o el proceso más tarde
             check_realloc_arr_error (* dirs_later_array);
             new_size = 1;
         } else {

             // Añadir directorios a la matriz de directorios
             new_size = (((sizeof (dirs_later_array) + sizeof (struct dirs_later *))) / sizeof (struct dirs_later *));
             // printf ("new size:% d", new_size);
         }
         dirs_later_array = realloc (dirs_later_array,
                 new_size * sizeof (struct dirs_later *));
         check_realloc_arr_error (dirs_later_array);
         dirs_later_array [new_size - 1] = new_dir;
     }
     return dirs_later_array;
 }



El tamaño del operador es una característica de tiempo de comstackción y solo verifica el tamaño estático de una expresión. Por lo tanto, para el puntero, solo devuelve el tamaño del puntero que es 4 en su plataforma. sizeof no mide el tamaño de los datos asignados dinámicamente. No hay una función estándar en C para obtener el tamaño de los datos asignados dinámicamente.

Su sizeof(struct dirs_later*) debe cambiarse a sizeof(struct dirs_later) , ¡como antes!

También el sizeof es una característica de tiempo de comstackción. Necesitas una estructura como esta para mantener el tamaño.

 struct my_dirs struct dirs_later *dirs; int size; }; 

Inicialízalo así

 struct my_dirs directories; directories.size = 0; directories.dirs = NULL; 

Luego para agregar (note realloc puede tomar NULL como parámetro

 directories.dirs = realloc(directories.dirs, (++directories.size) * sizeof(struct dirs_later)); 

Esto también simplificaría su código.