[c++]Coda statica circolare e non: cosa cambia?

[Alfoxx]

ciao a tutti ragazzi
potete farmi capire per favore cosa cambia tra una coda circolare e non, nella realizzazione c++.

//compilazione pre-condizionata
#ifndef CODA_H
#define CODA_H

//inclusione librerie
#include<iostream>
#include "Autovettura.h"

//spazio dei nomi standard
using namespace std;


typedef int E;

//definizione della classe
class Coda{
      private:
              static const int NMAX=100;
              int nelem;
              E *coda;
              int t, c;
              int presenti;//per verificare gli elementi effettivamente presenti
              
      public:
             //costruttore
             Coda(int n=0);
             //distruttore
             ~Coda(){delete []coda;}
             //costruttore di copia
             Coda(const Coda& ) ;
             //overloading operatore =
             const Coda & operator=(const Coda & ) ;
             
             void push(E);
             bool pop(E& ) ;
             bool top(E& ) ;
             bool empty()const{if(presenti==0)return true; else return false;}
             bool full()const{if(presenti==nelem)return true; else return false;}

};


#endif

questa è l'implementazione .
Il comando evidenziato dal testo in rosso mi fa capire che la coda è circolare?

#include "Coda.h"


//-------------costruttore-------------------
Coda::Coda(int n){
               nelem=n;
               t=0;
               c=0;
               presenti=0;
               coda=new E[nelem];
               
}

//-------------costruttore di copia-------------------

Coda::Coda(const Coda& c1){
                 t=c1.t;
                 nelem=c1.nelem;
                 c=c1.c;
                 coda=new E[nelem];
                 presenti=c1.presenti;
                 for (int i=0;i<nelem;i++) coda[i]=c1.coda[i];
}


//-------------overloading operatoe = -------------------
const Coda & Coda::operator= (const Coda & c1){
      if(this != &c1){
              delete [] coda;
              t=c1.t;
              nelem=c1.nelem;
              c=c1.c;
              coda=new E[c1.nelem];
              presenti=c1.presenti;
              for (int i=0;i<nelem;i++){ coda[i]=c1.coda[i];}



              }
       
      return *this;
}


void Coda::push(E e){
     if ( !full()){
         coda[t]=e;
         t=(t+1)%nelem;//fa la divisione e prende il modulo

è questo tipo di comando che mi fa diventare la coda circolare? 


         presenti++;
         }
     else cout<<"\ncoda piena impossibile inserire ulteriori elementi"<<endl;
}

bool Coda::pop(E& e){
     if( !empty()){
         e=coda[c];
         c=(c+1)%nelem;
         presenti--;
         return true;
         }
     else{
          cout<<"\ncoda vuota impossibile eliminare ulteriori elementi"<<endl;
          return false;
     }
}


bool Coda::top(E& e){
     if( !empty()){
         e=coda[c];
         return true;
         }
     else{
          cout<<"\ncoda vuota nessun elemento presente"<<endl;
          return false;
     }
}

[Who am I]

Circolare significa che quando si riempie si riniziano a scrivere gli elementi in prima posizione.E' FIFO, quindi se ha capacità N e aggiungi N+1 elementi, l' ultimo elemento va a sovrascrivere il primo aggiunto.
Ma la tua domanda specifica qual'è?

[Alfoxx]

ciao grazie per aver risposto
ma non chiedevo la spiegazione, ma piuttosto come si realizza l'una e l'altra coda.

Quello che ho postato è la soluzione per la coda circolare?

[Alfoxx]

nessuno?

[Who am I]

Ci sono tanti modi per realizzarla, uno è di usare un array di dimensioni fisse:

typedef struct __queue
{
    unsigned long maxLength;
    unsigned long length;
    int *data;
}queue;

queue* getQueue()
{
    queue* q= (queue*)malloc(sizeof(queue));
    q->length=0;
    q->maxLength=100;
    q->data=(int*)malloc(sizeof(int)*q->maxLength);
    return q;
}

void enqueue(queue* q, int value)
{
    q->data[q->length%100]=value;
    q->length++;
}

void deleteQueue(queue** q)
{
    free((*q)->data);
    free(*q);
    *q=NULL;
}

Concettualmente è una coda che quando raggiunge la sua massima grandezza va a sostituire gli elementi che sono stati aggiunti per primi, cronologicamente.
Ora puoi dirmi te se quel codice, che hai preso da qualche parte, implementa una coda circolare o no.