[C] stampa coda

[Oo.Tania.oO]

Perchè quando stampo la coda dopo aver estratto un elemento, continua a stamparmi anche l'elemento estratto?
Nel main:

TCoda coda;
    int i,x,n,ext;
    
    coda=Crea_Coda(5);
    
    printf("Quanti elementi vuoi inserire?");
    scanf("%d",&n);
    
    for(i=0;i<n;i++){
                                 printf("Elemento da inserire:");
                                 scanf("%d",&x);
                                 Aggiungi_Elemento(&coda,x);}
    for(i=0;i<n;i++){
                                 printf("%d  ",coda.array[i]);}
                                 
    printf("\n");
    ext=Prelievo_Elemento(&coda);
    printf("il numero estratto e':%d\n",ext);
    
    printf("Ora la coda e' formata da\n:");
    for(i=0;i<coda.n;i++){
                                 printf("%d  ",coda.array[i]);}
                                 printf("\n");

Funzione di estrazione:

 int Prelievo_Elemento(TCoda *coda){
       int x;
       x=coda->array[coda->front];
       coda->front++;
       coda->n--;
       return x;}

[demos88]

Mi sfuggono alcuni dettagli implementativi ma mi pare che tu usi un array come struttura per la coda.
Il ciclo di stampa però parte sempre dal primo elemento dell'array, non è che devi farlo partire dall'elemento array[front] ?
Nel codice in esame mi pare che effettui un solo prelievo, quindi presumo che front varrà 1.

[Oo.Tania.oO]

Si hai perfettamente ragione!!!
Ma quindi nel ciclo come inizializzo front?
Come viene il ciclo?

[demos88]

Originariamente inviato da Oo.Tania.oO

Si hai perfettamente ragione!!!
Ma quindi nel ciclo come inizializzo front?
Come viene il ciclo?

Beh quando crei la coda, front va settato a zero supponendo che il primo elemento prima di qualsiasi estrazione si trovi all'indice zero.
Poi ad ogni estrazione fai front++ e n-- (potresti magari usare anche un indice di fine coda anzichè lunghezza).

edit: mi sono accorto di non aver risposto precisamente alla tua domanda.
Nel ciclo for, inizializzi i=front e la condizione di uscita sarebbe i<(front + n). Ma questo vale solo se l'array non è circolare o se è abbastanza lungo per non porti il problema.
Più correttamente dovresti porre la condizione i != end, dove end è l'indice successivo all'indice dell'ultimo elemento inserito. In questo caso all'interno del corpo del for devi gestire il ritorno all'indice zero quando raggiungi fine array.

[Oo.Tania.oO]

Questo lo faccio nelle funzioni inserimento e di estrazione:

#include <stdio.h>
#include <stdlib.h>


struct SCoda{
       int n;
       int front;
       int back;
       int capienza;
       int *array;
       };
typedef struct SCoda TCoda;

TCoda Crea_Coda(int capienza);
void Aggiungi_Elemento(TCoda *coda,int x);
int Prelievo_Elemento(TCoda *coda);


int main(int argc, char *argv[])
{
    TCoda coda;
    int i,x,n,ext;
    
    coda=Crea_Coda(5);
    
    printf("Quanti elementi vuoi inserire?");
    scanf("%d",&n);
    
    for(i=0;i<n;i++){
                                 printf("Elemento da inserire:");
                                 scanf("%d",&x);
                                 Aggiungi_Elemento(&coda,x);}
    for(i=0;i<n;i++){
                                 printf("%d  ",coda.array[i]);}
                                 
    printf("\n");
    ext=Prelievo_Elemento(&coda);
    printf("il numero estratto e':%d\n",ext);
    
    printf("Ora la coda e' formata da\n:");
    for(i=1;i<coda.n;i++){
                                 printf("%d  ",coda.array[i]);}
                                 printf("\n");
                                 
    
  
  system("PAUSE");	
  return 0;
}

    
   TCoda Crea_Coda(int capienza){
      TCoda coda;
      coda.n=0;
      coda.back=0;
      coda.front=0;
      coda.capienza=capienza;
      coda.array=(int*)malloc(sizeof(int)*capienza);
      return coda;}
      
   void Aggiungi_Elemento(TCoda *coda,int x){
        coda->array[coda->back]=x;
        coda->back++;
        coda->n++;}
        
   int Prelievo_Elemento(TCoda *coda){
       int x;
       x=coda->array[coda->front];
       coda->front++;
       coda->n--;
       return x;}

il problema è che non so come usare il ciclo for per stampare dopo aver estratto...

[demos88]

Il ciclo for va adattato rispetto a come vuoi gestire l'array (la memoria allocata).
Se la tieni di dimensione fissa, devi prevedere uno sforamento a un certo punto e quindi implementare una gestione circolare. Altrimenti puoi gestire la cosa allocando continuamente nuova memoria (concettualmente inefficiente).
Nel tuo caso mi pare che la cosa proprio non la gestisci, siamo quindi nel caso più semplice: la coda sta tutta nella memoria allocata all'inizio e non raggiunge mai la fine perchè fai poche operazioni.

Il ciclo for in questo caso è molto semplice:

for (i = coda.front; i < coda.back; i++){
   printf("%d  ",coda.array[i]);
}

[Oo.Tania.oO]

Nel mio programma ho allocato la memoria dinamicamente: nella funzione crea coda quando inserisco la capienza mi prenoto in memoria un numero di celle grande tanto quanto voglio sia la mia capienza...non è efficiente?

gRAZIE 10000 comunque!!!

[demos88]

Originariamente inviato da Oo.Tania.oO

Nel mio programma ho allocato la memoria dinamicamente: nella funzione crea coda quando inserisco la capienza mi prenoto in memoria un numero di celle grande tanto quanto voglio sia la mia capienza...non è efficiente?

Nei moderni computer sicuramente non è problema (finchè si parla di qualche MB di memoria), concettualmente però allocare una grande memoria per un quantitativo di dati molto inferiore non è buona cosa.
Se per esempio sai che più o meno a ogni estrazione corrisponde un inserimento, vuol dire che nel tempo avrai una coda la cui dimensione ha un valore medio costante e una varianza non troppo estesa e puoi quindi allocare un quantitativo di memoria adeguato. Però senza array circolare avrai comunque il problema che a un certo punto sfori il tetto della memoria allocata, in quanto gli indici front e back possono solo aumentare.
La possibilità di ritornare a inizio della memoria allocata quando si raggiunge la fine, permette di riutilizzare la memoria agli indici più bassi, questo è a gran soldoni ciò che viene definito "circolarità".
Comunque per applicazioni di prova non è necessario, considera solo che a livello pratico, tutte le implementazioni di coda che puoi trovare in qualsiasi dispositivo elettronico (soprattutto sistemi embedded con memoria limitata) usano questo concetto.

In ogni caso funziona il ciclo di stampa o da ancora problemi?