Newsgroup: it.comp.lang.c
Titolo: Leggere dati (realloc di struct)

Il codice riportato sotto (in realtï¿œ ï¿œ solo un estratto...) non fa altro 
che reallocare memoria di dimensioni pari alla struct.
Ad ogni ciclo inserisco il nome e il cognome...
 
 
Come si fa per leggere tutti i dati memorizzati nella memoria allocata?
 
Con
printf ("%s/n", impiegato->nome);
printf ("%s/n", impiegato->cognome);
 
mi visualizza solo l'ultimo dato ingressato.
 
nero23
 
 
 
 
 
 
 
 
 
....
typedef struct
{
     char nome[nLMAX];
     char cognome[cLMAX];
} dati;
 
dati *impiegato;
....
.....
 
     impiegato = malloc(sizeof(dati));// alloco la memoria
     ...
     while(1)  // inizio ciclo while
         {
             impiegato =  realloc(impiegato, sizeof(dati));
              ....
              ...
 
 

              impiegato =  realloc(impiegato, sizeof(dati));
 
	A cosa serve la realloc se la size di dati non cambia ?
 
 
 
 
 

> Il codice riportato sotto (in realtï¿œ  Ãš solo un estratto...) non fa

ï¿œ un ciclo while...
ad ogni ciclo, inserisco il nome e il cognome, di conseguenza devo 
incrementare la memoria allocata

 incrementare la memoria allocata
 
 
nome e cognome sono a grandezza costante quindi anche dati ha una 
grandezza costante e quindi che senso ha il realloc ?
Inoltre la memoria allocata non aumenta in quanto la nuova size è sempre 
sizeof(dati)
 
impiegato = malloc(sizeof(dati));// alloco la memoria
while(1) {
	// blocco che elabora impiegato
}
 
free(impiegato);
 
 
 
 
 
 
 
 

 incrementare la memoria allocata
 
Stai sbagliando; come ti hanno già detto non devi incrementare niente, 
dato che allochi sempre la stessa memoria, mentre non deallochi quella 
vecchia.
 
Se ti serve allocare la memoria per salvare tutti gli impiegati letti, 
allora devi cambiare metodo.  Ti serve allocare un array di dati, e poi 
chiamare realloc se ti serve maggiore spazio.
 
Ad esempio
 
buf_size = 100; /* pre-alloca spazio per 100 impiegati */
n = 0; /* memoria usata */
buffer = malloc(buf_size * sizeof(dati);
 
while (1) {
  if (n >= buf_size) {
    buf_size *= 2;
    buffer = realloc(n * sizeof(dati);
  }
 
  buffer[n] = ...
  ++n;
}
 
Non testato.
 
 
Ciao  Manlio

 
 
Ciao  Manlio

Ho provato a seguire il tuo consiglio... sinceramente mi sono impappinato
 
Sotto ho riportato l'estratto del codice (non ti preoccupare del  cioclo 
while è infinito, è solo per semplificare il codice in fase di 
apprendimento   )
 
Dove devo apportare le modifiche che mi hai suggerito?
 
ciao
 
Giuseppe
 
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define nLMAX 20 // numero max di caratteri+2 per il nome (nLMAX 10 = 
massimo 8 caratteri)
#define cLMAX 20 // numero max di caratteri+2 per il cognome (cLMAX 10 = 
massimo 8 caratteri)
 
int main(void)
{
 
     typedef struct
     {
         char nome[nLMAX];
         char cognome[cLMAX];
     } dati;
 
     dati *impiegato;
 
     impiegato = malloc(sizeof(dati));// alloco la memoria
 
     while(1)  // CICLO INFINITO
         {
             impiegato =  realloc(impiegato, sizeof(dati));
 
 
             printf("Nome [max %d caratteri]: ", nLMAX-2);
             fgets(impiegato->nome, nLMAX, stdin);
 
 
             printf("Cognome [max %d caratteri]: ", cLMAX-2);
             fgets(impiegato->cognome, cLMAX , stdin);
 
 
         } // fine ciclo while
 
 
     free(impiegato);// libero la memoria
     return 0;
 
}
 

 [...]
 
 
Ciao  Manlio

 Dove devo apportare le modifiche che mi hai suggerito?
 
Io credo che tu non abbia ben capito a cosa serve realloc e a come si 
utilizza
Cercherò di spiegartelo in breve
Sostanzialmente realloc si usa per le strutture a valenza dinamica ed 
allocate nello heap (quindi si usa malloc per allocare)
Valenza dinamica significa applicare la realloc per quelle strutture la 
cui size varia nel tempo
Un esempio puo essere un array dove all' inizio allochi N oggetti e poi 
nel tempo N varia
 
Esempio di array:
 
struct T {...}; // una struttura
#define N 10    // la size iniziale dell' array
T* p=malloc(N * sizeof(T)); // alloca un array di N elementi di tipo T
p[0]=...; // assegna un valore di tipo T al primo elemento dell' array
 
...
p=realloc(p, (N*2)*sizeof(T)); // ora p punta ad un array di 20 elementi 
di tipo T
 
// qui p[0] ha il suo valore originale, cioè i vecchi elementi dell' 
array rimangono cosi come sono
 
..
 
free(p); // libera l' array
 
Credo che sia chiaro
 
 

Io non devo fare nulla di particolare. Cerco di capire come funziona il 
malloc e realloc. Sono partito dal codice riportato sotto.
 
Ora lo voglio modificare. Anzichè ingressare i numeri, voglio utilizzare 
la struct:
 
typedef struct
     {
         char nome[nLMAX];
         char cognome[cLMAX];
     } dati;
 
     dati *impiegato;
 
 
e alla fine, dopo aver inserito una serie di nome e cognome,  stampare 
tutto ..
 
Ciao
 
 
 
 
 
 
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
     int  nb;
     int i=0;
     int  n=0;
     int  ingresso;
     int  *array;
 
 
 
     int allocati;/* byte allocati */
     int dimbloc;/* byte in un blocco */
     int dimint;/* byte in un intero */
     int usati;/* byte contenenti interi */
 
     nb = 1;
 
     dimint = sizeof(int);
     dimbloc = nb * dimint;
     usati = 0;
 
     array = (int *)malloc(dimbloc);
     if(array == NULL)
         {
             printf("Memoria insufficiente\n");
             exit(1);
         }
 
     allocati = dimbloc;
 
     printf("Inserisci i numeri-Un carattere per uscire.\n");
     while(ingresso!=0)
         {
 
             scanf("%d", &ingresso);
 
             usati += dimint;
             if(usati>allocati)
                 {
                     allocati += dimbloc;
                     array = (int *)realloc(array, allocati);
                     if(array == NULL)
                         {
                             printf("Memoria insufficiente\n");
                             exit(1);
                         }
                     i++;
                 }
             /* in questo modo vengono letti n interi */
             array[n++] = ingresso;
         }
 
 
 
 
     /* stampo tutti i numeri digitati e relativo indirizzo di memoria */
     printf("\n NUMERO    INDIRIZZO\n");
 
     for (i = 0; i < n; i++)
         {
             printf("%5d", array[i]); // visualizzo i numeri memorizzati 
nel vettore
             printf("%15p\n", &array[i]); // visualizzo l'indirizzo dei 
  numeri memorizzati nel vettore
         }
     free(array); // libero la memoria allocata
     printf("\n");
 
     return 0;
}