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


codice:
//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?
codice:
#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;
     }
}