Newsgroup: it.comp.lang.c
Titolo: Coda

Salve, ragazzi, sto tentando di implementare una coda dinamica di tipo
FIFO.
L'unica cosa che sono riuscito a fare è una LIFO dinamica, ma per la FIFO
non so come fare la pop e liberare memoria.
Avete qualche suggerimento?
In tutti gli esempi che ho trovato, questa parte non è mai stata spiegata
bene sia che si parlava di coda dinamica con i puntatori ( credo sia un
obbligo usarli ), sia con le liste.
Il motivo per cui sto tentando di creare questa coda è per tenere le
coordinate della coda di un clone di snake che sto facendo sotto Linux.
Usando un array statico, il tutto funziona perfettamente, ma ovviamente
più di tanto la coda non si allunga e dovrei dare una dimensione
approssimativa all'array considerando la larghezza e l'altezza del campo
nel quale si muove il serpente ( potrebbe essere un metodo ), ma, anche a
scopo didattico, vorrei rendere il tutto dinamico e mi sono fermato sul
pop ( anche se un'idea di come procedere, me la sono fatta però preferirei
qualche buon consiglio da chi ne sa sicuramente di più di me ).
Grazie
Ciao by Siro
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 obbligo usarli ), sia con le liste.
non capisco quali sono queste due alternative ...
(Comunque penso che non sei proprio sul NG giusto)
Ciao.
Stefano.

 Ciao by Siro
Ciao,
penso che potresti usare una coda circolare,
cosi' definisci a priori la lunghezza dell'array.
In questo caso trovo comodo agionare con gli indici:
Tu inizi dall'indice 0 e vai avanti, quando raggiungi
la fine dell'array, invece di incrementare, riporti l'indice a 0.
Cio' vale per indici di inizio e fine coda.
Ah, naturalmente devi anche controllare di
non sovrascrivere i dati, cioe' di non inserire
nella coda se e' gia' piena.
( ho buttato giu' la risposta in fretta...
spero di non aver detto cavolate...)
Ciao
E.

 cosi' definisci a priori la lunghezza dell'array.
[CUT]
Ciao, grazie per la risposta, ma la prima volta l'ho fatto proprio in
questo modo e devo dire che funziona perfettamente. Volevo provare con una
coda dinamica più a scopo didattico che altro. Potrei anche accontentarmi
di farlo funzionare cosi, tanto in un array X x Y lo so già quanto potrà
allungarsi la coda, ma se volessi utilizzare parte del codice in altri
progetti, potrebbe non andar bene un array statico.
In mio problema è che non riesco a capire la logica della funzione pop.
In giro ho trovato molti esempi, ma mai spiegati. Ho visto che nella funz
pop dichiaro -> 
pop(){
  struct lista *tmp;
   tmp = coda->next;
  fa qualcosa e alla fine faccio il free(tmp)
 
}, ma non sono sicuro che la coda venga accorciata ( credo che dovrei fare
una realloc ).
Troppi dubbi, mi server un buon libro sull'allocazione dinamica della
memoria, ma soprattutto su come si libera la memoria allocata!


 Ciao by Siro
Ciao
Emilio

 memoria, ma soprattutto su come si libera la memoria allocata!
Francamente il tuo mi sembra un problema tipico e semplice da risolvere. Non
ti serve proprio niente di che, un paio di strutture e via:
struct nodo {
//le informazioni che ti servono
struct nodo *next; //prossimo nodo nella coda
}
struct coda {
        struct nodo *head;
        struct nodo *tail;
}
/* questa è una coda semplicemente concatenata, puoi fare una doppiamente
concatenata aggiungendo un campo nel nodo che punta al nodo precedente */
fine. Per quanto riguarda i dati :)
Per gestire la coda devi farti le funzioni ( pop() storicamente si usa per
le pile, quindi per non creare confuzione meglio enqueue e dequeue ).
void enqueue(struct coda *c, struct nodo *n) {
  if(c->tail!=NULL)
    c->tail->next = n;
  else
    //primo elemento
    c->head = n;
  c->tail = n;
}
struct nodo *dequeue(struct coda *c) {
  struct nodo *tmp;
  if(c->head!=NULL) {
    tmp = c->head;
    c->head = NULL;
    if(c->tail == tmp)
      //era l'ultimo elemento
      c->tail = NULL;
  }
  return tmp;
}
le ho buttate giù al volo ma dovrebbero bastare a farti capire. Non ti
consiglio di usarle così perché probabilmente c'é qualche errore
Ciao
Matteo
-- 
chi sono e soprattutto chi non sono:
http://noitre.ilnomedeldominio.it
un piccolo programma per studenti universitari:
nuova versione!!!! provatelo numerosi
http://inutility.ilnomedeldominio.it/imsv/

> Troppi dubbi, mi server un buon libro sull'allocazione dinamica 
Ah, mi sono dimenticato di chiarire una cosa.
Dov'é la dinamicità?
allochi le strutture nodo con malloc e quando non ti servono le liberi con
free.
struct nodo *n = malloc(sizeof(struct nodo));
//fai quello che devi fare
n = dequeue(lacoda);
//usi n;
free(n); //butti n :)
