04.06.2008 | 22:12:22
immagine
Ing. Emanuele Scapin

C, es3, gestione dinamica della memoria, il caso della coda e dello stack (pila).
  •  

  • Definizione della struct per la coda.

            typedef struct libro {
                char titolo[20];
                char autore[40];
                ...
                struct libro *succ; // puntatore all'elemento successivo
            } libro_t;
            
  • Funzione di inserimento in ultima posizione nella coda.

            libro_t *add(libro_t *c, char *titolo, ...) {
                    // allocazione nuovo elemento
                    libro_t *n = (libro_t *) malloc(sizeof(libro_t));
                    strcpy(n->titolo, titolo);
                    ...
                    n->succ = NULL;
    
                    // ricerca ultimo elemento della coda
                    libro_t *u = last(c);
    
                    // inserimento nuovo elemento come ultimo della coda
                    if (u != NULL) u->succ = n;
                    else c = n;
    
                    return c;
            } 
            
  • Funzione che rimuove un elemento dalla testa della coda (rimozione primo elemento della coda).

            libro_t *remove(libro_t *c) {
                    libro_t *p = c;
    
                    if ( c != NULL) {
                            c = c->succ;
                            free(p);
                    }
    
                    return c;
            }
            
  • Definizione della struct per lo stack (pila).
    Il puntatore al precedente anziché al successivo agevolerà la gestione dello stack pointer in fase di estrazione (pop).

            typedef struct libro {
                char titolo[20];
                char autore[40];
                ...
                struct libro *prec; // puntatore all'elemento precedente
            } libro_t;
    
            // definizione di due variabili globali
            libro_t *sp = NULL; // stack pointer
            libro_t *bp = NULL; // base pointer
            
  • Procedura per l'inserimento in testa (PUSH).

            void push(char *titolo, ...) {
                    libro_t *n = (libro_t *) malloc(sizeof(libro_t));
                    strcpy(n->titolo, titolo);
                    ...
                    n->prec = NULL;
    
                    if ((bp == NULL) && (sp == NULL)) {
                       // lo stack è vuoto
                       bp = n;
                       sp = n;
                    }
                    else {
                       // lo stack non è vuoto
                       n->prec = sp;
                       sp = n;	
                    }
            }
            
  • Funzione per estrazione dalla testa (POP).

            libro_t *pop() {
                libro_t *ret = NULL;
    
                if ((bp != NULL) && (sp != NULL)) {
                        if (bp == sp) {
                           ret = sp;
                           // stack rimane vuoto
                           sp = NULL;
                           bp = NULL;
                        }
                        else {
                           ret = sp;
                           // lo stack non rimane vuoto
                           sp = sp->prec	
                        }
                }
    
                return ret;
            }
            

© Emanuele Scapin 2009-2015

 

Valid HTML 4.01! Valid CSS!