Leggere dati (realloc di struct)

[NERO23]

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));
....
...

[enoquick]

Il 24/05/2013 00:30, NERO23 ha scritto:
> 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?
>

Attraverso i puntatori che puntano alla memoria dinamica

> Con
> printf ("%s/n", impiegato->nome);
> printf ("%s/n", impiegato->cognome);
>
> mi visualizza solo l'ultimo dato ingressato.
>

Ovvio

> 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));

A cosa serve la realloc se la size di dati non cambia ?

[NERO23]

Il 24/05/2013 15.06, enoquick ha scritto:
> Il 24/05/2013 00:30, NERO23 ha scritto:

>> 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

[enoquick]

Il 24/05/2013 12:19, NERO23 ha scritto:
> Il 24/05/2013 15.06, enoquick ha scritto:
>> Il 24/05/2013 00:30, NERO23 ha scritto:

>>> 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?
>>>
>>
>>
>> Attraverso i puntatori che puntano alla memoria dinamica
>>
>>
>>> Con
>>> printf ("%s/n", impiegato->nome);
>>> printf ("%s/n", impiegato->cognome);
>>>
>>> mi visualizza solo l'ultimo dato ingressato.
>>>
>>
>> Ovvio
>>> typedef struct
>>> {
>>> char nome[nLMAX];
>>> char cognome[cLMAX];
>>> } dati;
>>>
>>> dati *impiegato;
>>> ....
>>> .....

>>>impiegato->nome[strlen(impiegato->nome) - 1]

>>> impiegato = malloc(sizeof(dati));// alloco la memoria
>>> ...
>>> while(1) // inizio ciclo while
>>> {
>>> impiegato = realloc(impiegato, sizeof(dati));
>>
>> A cosa serve la realloc se la size di dati non cambia ?
>
>

> è un ciclo while...

> ad ogni ciclo, inserisco il nome e il cognome, di conseguenza devo
> 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);

[Manlio Perillo]

Il Fri, 24 May 2013 19:19:10 +0200, NERO23 ha scritto:

> [...]

>>> 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));
>>
>> A cosa serve la realloc se la size di dati non cambia ?
>
>

> è un ciclo while...

> ad ogni ciclo, inserisco il nome e il cognome, di conseguenza devo
> 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

[Manlio Perillo]

Il Fri, 24 May 2013 17:59:36 +0000, Manlio Perillo ha scritto:

> [...]

Ci sono un paio di errori che ho fatto su realloc.

Il primo è che realloc *dealloca* la memoria:

> Stai sbagliando; come ti hanno già detto non devi incrementare niente,
> dato che allochi sempre la stessa memoria, mentre non deallochi quella
> vecchia.
>

Ed il secondo è che ho dimenticato un parametro (ed una parentesi):

> buffer = realloc(n * sizeof(dati);

realloc(buffer, n * sizeof(dati));
> }
>

Ciao Manlio

[NERO23]

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;

}

[Manlio Perillo]

Il Tue, 28 May 2013 13:11:09 +0200, NERO23 ha scritto:

> Ho provato a seguire il tuo consiglio... sinceramente mi sono
> impappinato
>

Dove?

> 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?
>

Magari dovresti spiegare meglio cosa vuoi fare.
Leggere tutti i dati degli impiegati da un file, per farci poi cosa?

> [...]

> 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));
>

Cosa ti aspetti che faccia realloc in questa situazione?
Che uso devi fare di impiegato in seguito?

> [...]


Ciao Manlio

[enoquick]

Il 28/05/2013 06:11, NERO23 ha scritto:
> 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?

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

[NERO23]

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;
}