[C] Uso di Realloc per allocare struct

[gaten]

Salve ragazzi, ho creato il seguente tipo di dati:

#define STEP_GRAFO 100 

typedef struct grafo
{
        NODO **archi;
        int PrimoLibero;
        int NumNodi;
        int N_Max;
        void **dizionario;
        NODO *FreeList;
        // eventuali f di callback
} GRAFO;

ed ho la seguente funzione InitG per inizializzare il grafo:

GRAFO *InitG(GRAFO *G)
{
      int i;
      
      G = (GRAFO*)malloc(sizeof(GRAFO));
      G->NumNodi = 0;
      G->PrimoLibero = 0;
      G->N_Max = STEP_GRAFO;
      G->archi = (NODO**)malloc(sizeof(NODO) * G->N_Max);
      G->dizionario = (void**)malloc(sizeof(void*) * G->N_Max );
      
      // inizializzazione necessaria 
      for ( i = 0; i < G->N_Max; i++ )
          G->dizionario[i] = NULL;
      
      // inizializzazione necessaria 
      for ( i = 0; i < G->N_Max; i++ )
          G->archi[i] = NULL;
      
      G->FreeList = NULL;
      
      return G;
}

Adesso devo fare in modo tale che, qualora ho:

if ( G->NumNodi == G->N_Max )
{
    // devo effettuare la realloc;
    // riallocando G->archi di + STEP_NODO(cioè 100);
}

Qualcuno può aiutarmi?

Inoltre nella init ho dovuto per forza inizializzare tutto a NULL altrimenti se facevo controlli del tipo:

G->dizionario[i] == NULL, mi si bloccava! (provando a stampare, stampava valori sporchi, e penso sia normale. Quindi è giusto inizializzare a null?? Lo domando poichè un mio amico mi ha detto che quando alloco con la malloc in automatico viene settato tutto a NULL, penso si sbagliava).

[Scara95]

G->dizionario = (void**)malloc(sizeof(void*) * G->N_Max );

Vorrei farti notare che questa allocazione di memoria ha poco senso, un puntatore a void è un puntatore a un'area di memoria senza una dimensione specifica (anche se alcuni garantiscono una grandezza pari a quella di un int per un void*, in ogni caso non è corretta e non ha un significato logico).

Secondo:
malloc non setta la memoria a 0
calloc setta la memoria a zero

Terzo:
Non vedo dove sia il problema...
Basta che chiami realloc reimpostanto la memoria da allocare...
realloc :
primo argomento la variabile con la memoria già allocata, secondo argomento la nuova size...

[gaten]

Riguardo al malloc dell'array di puntatori a void sono d'accordo con te.
Sono d'accordo anche nell'utilizzare calloc(grazie per la delucidazione).

Riguardo alla realloc dovrei avere una cosa del tipo:

G->archi = (NODO**)realloc(G->archi, G->N_Max+STEP_GRAFO);

Utilizzando la realloc, avrò tutti i nuovi puntatori che puntano a NULL?

[Scara95]

Originariamente inviato da gaten
Utilizzando la realloc, avrò tutti i nuovi puntatori che puntano a NULL?

Certo che no, non setta a zero la memoria, anche perchè è conservativa (conserva ciò che avevi precedentemente)...

[gaten]

MI sono espresso male, la nuova memoria che viene allocata (premettendo che quella precedente resta invariata) conterrà puntatori che puntano a NULL (cosa che mi serve perciò ci martello su).

[Scara95]

No, devi provvedere a settarla a 0 se vuoi che sia così settata...

[Scara95]

Non mi ero accorto:
dovrebbe essere

G->archi = (NODO**)realloc(G->archi, sizeof(NODO)*(G->N_Max+STEP_GRAFO));

e non

G->archi = (NODO**)realloc(G->archi, G->N_Max+STEP_GRAFO);

[gaten]

Ok, grazie!
Ora l'unico problema è che non inizializzando a NULL i nuovi nodi allocati, ho il problema nel fare il confronto:

if (G->dizionario[u] != NULL && G->dizionario[v] != NULL )

Praticamente entra in questo if anche quando alloco memoria ma in realtà gli indirizzi puntanto a qualcosa di insensato e questo non mi và bene..
Sono costretto a fare una cosa del tipo:

NODO **NewArchi;

NewArchi = (NODO**)calloc(STEP_NODO, sizeof(NODO));

G->archi = (NODO**)realloc(NewArchi, G->N_Max+STEP_NODO);

Andrebbe bene così?

[Scara95]

NODO **NewArchi;

NewArchi = (NODO**)calloc(STEP_NODO, sizeof(NODO));

G->archi = (NODO**)realloc(NewArchi, G->N_Max+STEP_NODO);

E' totalmente scorretto inquanto prima allochi una nuova area di memoria e poi espandi quella, non espandi l'array che avevi prima...

Devi provvedere ad inizializzarli a mano.

[gaten]

O.O

Così espando NewArchi???

G->archi = (NODO**)realloc(NewArchi, G->N_Max+STEP_NODO);