ciao a tutti, ho creato la struttura dati lista con cursore. è una lista derivata dove il costruttore invoca il costruttore della classe base (almeno dovrebbe) però quando compilo il test per verificare se i metodi sono corretti mi dà errore anche se penso sia fatto tutto corretto. posto i codici.

lista.h
codice:
#ifndef lista_h
#define lista_h

#include<iostream>
#include<stdlib.h>

using namespace std;

template<class posizione, class tipoelem>
class lista
{
   public:
      lista(int);    
          
      virtual void crealista() = 0;
      virtual bool listavuota() = 0;
      virtual posizione primolista() = 0;
      virtual bool finelista(posizione) = 0;
      virtual tipoelem leggilista(posizione) = 0;
      virtual void scrivilista(posizione, tipoelem) = 0;
      virtual posizione predlista(posizione) = 0;
      virtual posizione suclista(posizione) = 0;
      virtual void inslista(posizione, tipoelem) = 0;
      virtual void canclista(posizione) = 0;
   
      void stampalista();
      void epuraordinata();
   private:
      bool tipolista[3];
};

#endif

template<class posizione, class tipoelem>
lista<posizione, tipoelem>::lista(int tipolis)
{
   /*questo costruttore serve per sapere di quale tipo è la lista (vettore, 
     puntatore o cursore, in quanto alcuni metodi (inslista e canclista) 
     svolgono azioni diverse in base al tipo di lista, cioè con la lista di
     puntatori i metodi aggiornano la posizione mentre con laa lista di vettori
     la posizione non viene aggiornata e quini c'è bisogno di aggiornarla
     dal metodo o funzione o programma che invoca il metodo.
     lista con vettore = 1
     lista con puntatore = 2
     lista con cursori = 3.*/
   if(tipolis == 0)
   {
      tipolista[0] = true;
      tipolista[1] = tipolista[2] = false;
   }
   else if(tipolis == 1)
        {
           tipolista[1] = true;
           tipolista[0] = tipolista[2] = false;
        }
        else
        {
           tipolista[2] = true;
           tipolista[0] = tipolista[1] = false;
        }
   cout << "tipolista = " << tipolista[tipolis] << "\n\n";
}

template<class posizione, class tipoelem>
void lista<posizione, tipoelem>::stampalista()
{
   posizione p = this->primolista();
   while(!this->finelista(p))
   {
      cout << this->leggilista(p) << "\n";
      p = this->suclista(p);
   }
   if(tipolista[0] || tipolista[1]) //è una lista con vettore o puntatore?
      cout << this->leggilista(p) << "\n";
   cout << "\n\n";
}

template<class posizione, class tipoelem>
void lista<posizione, tipoelem>::epuraordinata()
{
   posizione p = this->primolista();
   posizione q = this->suclista(p);
   while(!this->finelista(p))
   {
      while(this->leggilista(q) == this->leggilista(p))
         this->canclista(q);
      p = this->suclista(p);
      q = this->suclista(p);
   }
}
listac.h
codice:
#ifndef listac_h
#define listac_h

#include<iostream>
#include<stdlib.h>
#include "lista.h"

#define MAXDIM 100

using namespace std;

template<class tipoelem>
class listac : public lista<int, tipoelem>
{
   public:
      typedef int posizione;
      listac();
      
      void crealista();
      bool listavuota();
      posizione primolista();
      bool finelista(posizione);
      tipoelem leggilista(posizione);
      void scrivilista(posizione, tipoelem);
      posizione predlista(posizione);
      posizione suclista(posizione);
      void inslista(posizione, tipoelem);
      void canclista(posizione);
      
      void sposta(posizione *, posizione *);
   private:
      typedef struct Nodo
      {
         posizione precedente;
         tipoelem elemento;
         posizione successivo;
      } nodoc;
      static nodoc *spazio;
      //static posizione listavuota;
      static nodoc *inizializzalistalibera();
      static bool inizializzato;
      static posizione listalibera;
      static int lunglistalibera;
      posizione lista;
      int lunglista;
};

#endif

//                     INIZIALIZZAZIONE DEI MEMBRI STATICI
template<class tipoelem>
bool listac<tipoelem>::inizializzato = false;

template<class tipoelem>
typename listac<tipoelem>::nodoc *listac<tipoelem>::spazio = inizializzalistalibera();

template<class tipoelem>
typename listac<tipoelem>::nodoc *listac<tipoelem>::inizializzalistalibera()
{
   spazio = new nodoc[MAXDIM];
   cout << "MAXDIM = " << MAXDIM << "\n";
   if(!inizializzato)
   {
      for(int i = 0; i < MAXDIM; i++)
      {
         if(i == 0)
         {
            spazio[i].precedente = MAXDIM - 1;
            spazio[i].elemento = i;
            spazio[i].successivo = 1;
         }
         else
         {
            spazio[i].precedente = ((i - 1) % MAXDIM);
            spazio[i].elemento = i;
            spazio[i].successivo = ((i + 1) % MAXDIM);
         }
      }
      inizializzato = true;
      lunglistalibera = MAXDIM;
   }
   return spazio;
}

template<class tipoelem>
typename listac<tipoelem>::posizione listac<tipoelem>::listalibera = 0;

template<class tipoelem>
void listac<tipoelem>::sposta(typename listac<tipoelem>::posizione *pos1, typename listac<tipoelem>::posizione *pos2)
{
   posizione temp = *pos1;
   *pos1 = spazio[*pos1].successivo;
   spazio[spazio[temp].successivo].precedente = spazio[temp].precedente;
   spazio[spazio[temp].precedente].successivo = spazio[temp].successivo;
   spazio[temp].precedente = spazio[*pos2].precedente;
   spazio[temp].successivo = *pos2;
   spazio[spazio[*pos2].precedente].successivo = temp;
   spazio[*pos2].precedente = temp;
   *pos2 = temp;
}

template<class tipoelem>
int listac<tipoelem>::lunglistalibera = 0;

//                    COSTRUTTORE
template<class tipoelem>
listac<tipoelem>::listac() : lista<int, tipoelem>(2)
{
   this->crealista();
}

//                    METODI 
template<class tipoelem>
void listac<tipoelem>::crealista()
{
   lista = -1;
   lunglista = 0;
}

template<class tipoelem>
bool listac<tipoelem>::listavuota()
{
   return(lunglista == 0);
}

template<class tipoelem>
typename listac<tipoelem>::posizione listac<tipoelem>::primolista()
{
   return(lista);
}

template<class tipoelem>
bool listac<tipoelem>::finelista(typename listac<tipoelem>::posizione pos)
{
   return(spazio[pos].successivo == lista);
}

template<class tipoelem>
tipoelem listac<tipoelem>::leggilista(typename listac<tipoelem>::posizione pos)
{
   return(spazio[pos].elemento);
}

template<class tipoelem>
void listac<tipoelem>::scrivilista(typename listac<tipoelem>::posizione pos, tipoelem elem)
{
   spazio[pos].elemento = elem;
}

template<class tipoelem>
typename listac<tipoelem>::posizione listac<tipoelem>::predlista(typename listac<tipoelem>::posizione pos)
{
   return(spazio[pos].precedente);
}

template<class tipoelem>
typename listac<tipoelem>::posizione listac<tipoelem>::suclista(typename listac<tipoelem>::posizione pos)
{
   return(spazio[pos].successivo);
}

template<class tipoelem>
void listac<tipoelem>::inslista(typename listac<tipoelem>::posizione pos, tipoelem elem)
{
   if(this->listavuota())
   {
      lista = listalibera;
      listalibera = spazio[listalibera].successivo;
      spazio[spazio[lista].precedente].successivo = listalibera;
      spazio[listalibera].precedente = spazio[lista].precedente;
      spazio[lista].precedente = lista;
      spazio[lista].successivo = lista;
      spazio[lista].elemento = elem;
   }
   else
   {
      if(pos == lista)
      {
         sposta(&listalibera, &lista);
         spazio[lista].elemento = elem;
      }
      else
      {
         sposta(&listalibera, &pos);
         spazio[pos].elemento = elem;
      }
   }
   lunglista++;
   lunglistalibera--;
}

template<class tipoelem>
void listac<tipoelem>::canclista(typename listac<tipoelem>::posizione pos)
{
   if(pos == lista)
   {
      spazio[lista].elemento = lista;
      sposta(&lista, &listalibera);
   }
   else
   {
      spazio[pos].elemento = pos;
      sposta(&pos, &listalibera);
   }
   lunglista--;
   lunglistalibera++;
   if(lunglista == 0)
      lista = -1;
}
testlistac.cpp
codice:
#include "listac.h"
#include<iostream>
#include<stdlib.h>

using namespace std;

int main()
{
   listac<int> list(20);
      
   cout << "listavuota() = " << list.listavuota() << "\n";
   cout << "primolista() = " << list.primolista() << "\n";
   cout << "finelista(primolista()) = " << list.finelista(list.primolista()) << "\n";
   cout << "leggilista(primolista()) = " << list.leggilista(list.primolista()) << "\n";
   list.scrivilista(list.primolista(), 10);
   cout << "leggilista(primolista()) = " << list.leggilista(list.primolista()) << "\n";
   cout << "predlista(primolista()) = " << list.predlista(list.primolista()) << "\n";
   cout << "suclista(primolista()) = " << list.suclista(list.primolista()) << "\n";
   cout << "primolista() = " << list.primolista() << "\n";
   for(int i = 0; i < 10; i++)
   {
      list.inslista(list.primolista(), (i * 10));
   }
   list.stampalista();
   cout << "\n\n";
   list.stampalista();
   list.canclista(list.primolista());
   listac<int>::posizione p = list.primolista();
   for(int i = 0; i < 4; i++)
      p = list.suclista(p);
   list.canclista(p);
   list.stampalista();
   
   system("cls");
   int k;
   listac<int> list2;
   listac<int>::posizione p2 = list2.primolista();
   for(int i = 0; i < 10; i++)
   {
      cin >> k;
      list2.inslista(p2, k);
      p2 = list2.suclista(p2);
   }
   list2.stampalista();
   list2.epuraordinata();
   list2.stampalista();
   
   system("pause");
   return 0;
}
ora, gli errori che mi vengono segnalati sono alla riga 107 del file listac.h (in rosso) e sono i seguenti:

107 C:\Dev-Cpp\Lista\listac.h expected `(' before '<' token
107 C:\Dev-Cpp\Lista\listac.h expected `{' before '<' token
107 C:\Dev-Cpp\Lista\listac.h At global scope:
107 C:\Dev-Cpp\Lista\listac.h expected unqualified-id before '<' token
107 C:\Dev-Cpp\Lista\listac.h expected `,' or `;' before '<' token

quello che mi chiedo io è: perchè mi da questi errori dato che ho creato anche le liste con puntatori e vettore i cui costruttori sono fatti nello stesso modo del costruttore di questa lista??