[C] Allocazione dinamica di una struttura

[adrian1984]

Ciao a tutti
Ho dei problemi con l'allocazione dinamica di una struttura, vi espongo i vari passaggi che ho fatto:

Supponiamo che ho una struttura di tipo TABELLA con due campi:
Nome di tipo char ed Età di tipo integer

nel main dichiaro un array di puntatori al tipo TABELLA:
TABELLA *Persona;

ora voglio passare persona ad una funzione CreaArray che alloca dinamicamente quindi passo Persona per indirizzo in modo tale che venga modificato
CreaArray(&Persona)

il prototipo di questa funzione dovrebbe essere del tipo:
void CreaArray(TABELLA **)
in modo da andare a selezionare il puntatore ad inizio array di puntatori

nella funzione Crea array devo fare essenzialmente 3 cose:
1) chiamare una funzione Alloca
2) entrare in un ciclo che legge parole e le memorizza nella struttura
3) nel ciclo si chiama una funzione Rialloca che aumenta lo spazio di Persona

ora vorrei sapere come sono fatte le due funzioni Alloca e Rialloca, con rispettivamente la malloc e la realloc, e magari anche il loro prototipi.

Grazie

[oregon]

Un attimo, prima di continuare ...

se scrivi

TABELLA *Persona;

avrai un puntatore ad una struttura di tipo TABELLA e non ad un array di puntatori di tipo TABELLA ...

Se ragioniamo con il codice che stai scrivendo e' meglio ...

[adrian1984]

Originariamente inviato da oregon
Un attimo, prima di continuare ...

se scrivi

TABELLA *Persona;

avrai un puntatore ad una struttura di tipo TABELLA e non ad un array di puntatori di tipo TABELLA ...

Se ragioniamo con il codice che stai scrivendo e' meglio ...

oregon il programma è lo stesso per cui mi hai aiutato l'altra volta
di seguito posto il codice



struct { char Parola[40]; int Occorrenza;} ELENCO;
main()
{
int NumElem;
char NomeFile[LENMAX];
ELENCO *Index;
NumElem=CreaStruttura(NomeFile,&Index);


int CreaStruttura(char *NomeFile, ELENCO **Indice)
{
int NumElem, DimText;
NumElem=-1;
DimText=Alloca (&Indice,DimText);
while (! feof(Pf))
{
if (NumElem >= DimText-1)
DimText= Rialloca(Indice, NumElem, DimText);
........
........
return NumElem;
}


int Alloca (ELENCO ** Indice,int DimText)
{
int i;
DimText=BLOCCO;
Indice = (ELENCO **) malloc (BLOCCO * sizeof (ELENCO *)); /*Questa forma è detta coecizione*/
if ( Indice == NULL) /*Controllo che l'operazione di allocazione sia andata a buon fine, altrimenti esco con un warning */
printf ("Error: Out of Memory \n"), system ("pause"), exit(1);
for(i=0; i<BLOCCO;i++)
Indice[i]=(ELENCO*)malloc(sizeof(ELENCO));
return DimText;
}


int Rialloca(ELENCO **Indice, int NumElem, int DimText)
{
ELENCO **Q;
int i;
DimText+=BLOCCO;
Q=realloc (Indice, DimText);
if (Q)
{
Indice=Q;
for (i = DimText-BLOCCO; i < DimText ;i++)
Indice[i]=(ELENCO*) malloc (sizeof(ELENCO));
printf("Sono stati allocati %d byte \n", DimText);
}
else
printf("Error: Out of Memory \n"), system ("pause"), exit(1);
return DimText;
}

[MacApp]

Ingloba il codice che mandi tra i tag (sostituendo al posto delle graffe le quadre)
{code} {/code} o {php}{/php}, altrimenti è difficile leggere "al volo" il codice.
Meglio poi se il codice è compilabile.

Tre piccoli consigli:
1. Se vuoi creare una funzione che alloca dinamicamente una struttura di tipo SElenco ti consiglio il seguente prototipo:

SElenco * NewSElenco (parametri vari di inizializzazione); 

Non chiamarla "Alloca" perché in alcuni sistemi operativi "alloc" viene usato per allocare dinamicamente nello stack anziché nell'heap.

EDIT: in particolare se NewSElenco non riesce ad allocare la struttura, restituirà NULL al chiamante.

2. Inizializza a NULL i puntatori, ad esempio (dal tuo codice):

ELENCO *Index = NULL; /* not always necessary, but it will save me lot of debugging */ 

3. Gli identificatori tutti MAIUSCOLOSI in C sono solitamente delle define, delle costanti, non usarli per le strutture.

Una nota positiva:
Ottimo il fatto che controlli (ma non sempre) i valori restituiti da malloc e realloc;

EDIT 2: considera anche che poi tutto quello che allochi dinamicamente, lo devi "disallocare".

[adrian1984]

Originariamente inviato da MacApp
Ingloba il codice che mandi tra i tag (sostituendo al posto delle graffe le quadre)
{code} {/code} o {php}{/php}, altrimenti è difficile leggere "al volo" il codice.
Meglio poi se il codice è compilabile.

Tre piccoli consigli:
1. Se vuoi creare una funzione che alloca dinamicamente una struttura di tipo SElenco ti consiglio il seguente prototipo:

SElenco * NewSElenco (parametri vari di inizializzazione); 

Non chiamarla "Alloca" perché in alcuni sistemi operativi "alloc" viene usato per allocare dinamicamente nello stack anziché nell'heap.

EDIT: in particolare se NewSElenco non riesce ad allocare la struttura, restituirà NULL al chiamante.

2. Inizializza a NULL i puntatori, ad esempio (dal tuo codice):

ELENCO *Index = NULL; /* not always necessary, but it will save me lot of debugging */ 

3. Gli identificatori tutti MAIUSCOLOSI in C sono solitamente delle define, delle costanti, non usarli per le strutture.

Una nota positiva:
Ottimo il fatto che controlli (ma non sempre) i valori restituiti da malloc e realloc;

EDIT 2: considera anche che poi tutto quello che allochi dinamicamente, lo devi "disallocare".

grazie per i consigli
riguardo la funzione Rialloca dove uso la realloc dici che va bene?

[MacApp]

Originariamente inviato da adrian1984
grazie per i consigli
riguardo la funzione Rialloca dove uso la realloc dici che va bene?

Sinceramente? Butta via tutto e reincomincia da capo.
Prima sviluppa un qualcosa che allochi dinamicamente (e "disallochi") un tipo primitivo (ad esempio un int), compreso la gestione degli errori.

Poi con una struttura (ma se avrai fatto bene il primo esercizio ti basterà un typedef)

Quindi con un vettore di primitivi (int), poi (sempre con un typedef) di strutture.

Ed alla fine con un vettore dinamico di strutture dinamiche.

Importantissimo: ciò che allochi DEVE essere liberato regolarmente alla fine del programma, anche in caso di errore runtime (mancanza di memoria), senza far crashare il programma.

Non è un lavoro semplice, perciò incomincia dalle cose semplici.

filosoficamente MacApp ;-)

EDIT: non pensare alla realloc, pensa solo a malloc e free.