Newsgroup: it.comp.lang.c
Titolo: memcpy crashante...

Salve a tutti!
Ho dei problemi con un programma che sto sviluppando, e ho passato la
mattina a chiedermi cosa c'e' di sbagliato in questa istruzione:
   memcpy( (void*) (*(*descr+count-1)).cod, buffer, 14 );
In pratica devo leggere da un file un numero ignoto a priori di record, da
inserire in uno spazio di memoria ridimensionabile con realloc. descr e' il
parametro di questa funzione, di tipo **d_alt (dove d_alt e' una struttura
definita con typedef che fra gli altri campi ha
    char cod[14];
che sto tentando di riempire con il contenuto del vettore di caratteri
"buffer". count e' naturalmente il contatore dei record letti ed inseriti.
Ho provato tutte le varianti e cast espliciti possibili, seguendo
pedissequamente il buon vecchio K&R ma tutto quel che ottengo eseguendo il
programma (che compila senza problemi) e' sempre e solo un bel "core dumped"
in corrispondenza della memcpy... Ah, dimenticavo, sono sotto SCO O.S. (ma
non credo che faccia differenza).
Ciao a tutti e buone compilazioni :)

    memcpy( (void*) (*(*descr+count-1)).cod, buffer, 14 );
Dovresti postare il codice del programma per avere una visuale piu' ampia del
problema.
Ivan Molella

   memcpy( (void*) (*(*descr+count-1)).cod, buffer, 14 );
usa strncpy(), la sintassi e' qualcosa di simile a questa :
strncpy( descr[count-1]->cod, buffer, 14 ) ;
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
---------------------------------------------

usa strncpy(), la sintassi e' qualcosa di simile a questa :
Gia' fatto, nell'ordine ho usato: strcpy, strncpy (pensando a problemi 
di buffer overflow), memcpy, con gli stessi risultati... Il codice della 
funzione incriminata e' nell'altro msg.

funzione incriminata e' nell'altro msg.
Allora credo che dovresti postare il programma completo.

Allora credo che dovresti postare il programma completo.
hihihi e' che non e' ancora partito... ho fatto casino con News 
Xpress... qualche minuto ancora!

problema.
Ecco la funzione incriminata, con un po' di commenti...
/*** d_alt e' una struttura definita con typedef, e descr ***/
/*** e' un puntatore a un vettore di queste strutture     ***/
short leggi_descalt(d_alt **descr)
{
  short count = 0;
  short list_n;
  is_open(&falt, "descalt", "w", "logsys", &errore);
  ralt.cod_art := rmag.mag_cod;
  is_start(falt, 4, &ralt, lalt, &errore);
  left(w, ralt.cod_art, 14);
  left(w1, rmag.mag_cod, 14);
  /* In questo ciclo leggo un file alla ricerca di record il cui */
  /* codice (cod. articolo) sia uguale a quello di controllo     */
  while (!errore && w == w1)
        {
          /* Ridimensiono il vettore per ogni elemento trovato */
          descr = (d_alt**)realloc((void*)descr, (++count) *
                                                 sizeof(d_alt));
          /* Qui crasha... vorrei copiare i dati nel nuovo */
          /* spazio ma probabilmente non ho capito bene il */
          /* meccanismo delle ***alloc, che effettivamente */
          /* e' la prima volta che uso 8-)                 */
          memcpy( (void*) (*(*descr+count-1)).cod, ralt.cod_art, 14 );
          memcpy( (void*) (*(*descr+count-1)).desc, ralt.cod_des, 30 );
          (*(*descr+count-1)).codnaz = ralt.cod_naz;
          for (list_n=0; list_n<4; list_n++)
              (*(*descr+count-1)).list[list_n] = ralt.listino[list_n];
          /* Leggo il prossimo record */
          is_next(falt, 4, &ralt, lalt, errore);
          left(w, ralt.cod_art, 14);
          left(w1, rmag.mag_cod, 14);
        }
  is_close(falt, &errore);
  return count;
}

inserire in uno spazio di memoria ridimensionabile con realloc. descr e' il
Ho trovato la soluzione con il classico "provando e riprovando". In 
pratica l'errore che commettevo era di pensare in termini di "puntatore 
a vettore di struct" invece di "puntatore a vettore di puntatori a 
struct"... Questo si traduceva nell'usare realloc() in maniera errata e 
nell'omissione totale di una malloc() con cui fare spazio per la struct 
vera e propria. Ecco il codice modificato e ora funzionante (e mi sono 
ricordato pure dell'operatore "->"):
/*** Ho corretto il sizeof() in fondo ***/
descr = (d_alt**)realloc((void*)descr, (++count) * sizeof(d_alt*));
descr[count-1] = (d_alt*)malloc(sizeof(d_alt));
/*** Il malloc() invece mancava del tutto ***/
/*** Ora tutto funziona, e probabilmente le strncpy sono
     superflue ***/
strncpy(buffer, ralt.cod_art, 14);
memcpy( (void*) descr[count-1]->cod, buffer, 14 );
strncpy(buffer, ralt.des_art, 30);
memcpy( (void*) descr[count-1]->desc, buffer, 30 );
descr[count-1]->codnaz = ralt.cod_naz;
for (list_n=0; list_n<4; list_n++)
    descr[count-1]->list[list_n] = ralt.listino[list_n];
is_next(falt, 4, &ralt, lalt, &errore);
left(w, ralt.cod_art, 14);
left(w1, rmag.mag_cod, 14);
Ancora TNX per l'attenzione (l'avevo detto che ero un po' arrugginito 
coi puntatori...) ^__^
 *** Firebeam by ELAND INFORMATICA ***