ciao a tutti, ho creato la struttura dati lista come classe base con dei metodi virtuali, dopo di che ho implementato i metodi virtuali nella classe derivata. nel test della classe mi da un errore che non riesco a comprendere a cosa sia dovuto. ecco 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:
      virtual void crealista() = 0;
      virtual bool listavuota() = 0;
      virtual posizione primolista() = 0;
      virtual bool finelista(posizione) = 0;
      virtual posizione succlista(posizione) = 0;
      virtual posizione predlista(posizione) = 0;
      virtual tipoelem leggilista(posizione) = 0;
      virtual void scrivilista(poszione, tipoelem) = 0;
      virtual void inslista(posizione, tipoelem) = 0;
      virtual void canclista(posizione) = 0;
      
      void fondiordinate(lista &, lista &);
      void epurazione();
      void naturalmergesort();
   private:
      void distribuisci(lista &, lista &);
      void copiacatena(posizione &, lista, posizione &, lista &);
      void copia(posizione &, lista, posizione &, lista &, bool &);
      void merge(lista, lista, lista &, int &);
      void findicatena(posizione &, lista, posizione &, lista, posizione &, lista &);
      
};

#endif

template<class posizione, class tipoelem>
void lista<posizione, tipoelem>::fondiordinate(lista<posizione, tipoelem> &a, lista<posizione, tipoelem> &b)
{
   posizione pa = a.primolista();
   posizione pb = b.primolista();
   posizione pc = primolista();
   
   while(!a.finelista(pa) && !b.finelista(pb))
   {
      if(a.leggilista(pa) <= b.leggilista(pb))
      {
         inslista(pc, a.leggilista(pa));
         pa = a.succlista(pa);
      }
      else
      {
         inslista(pc, b.leggilista(pb));
         pb = b.succlista(pb);
      }
      pc = succlista(pc);
   }
   
   while(!a.finelista(pa))
   {
      inslista(pc, a.leggilista(pa));
      pa = a.succlista(pa);
      pc = succlista(pc);
   }
   while(!b.finelista(pb))
   {
      inslista(pc, b.leggilista(pb));
      pb = b.succlista(pb);
      pc = succlista(pc);
   }
}

template<class posizione, class tipoelem>
void lista<posizione, tipoelem>::epurazione()
{
   posizione p = primolista();
   posizione q;
   posizione t;
   while(!finelista(p))
   {
      q = succlista(p);
      while(!finelista(q))
      {
         if(leggilista(p) == leggilista(q))
         {
            t = succlista(q);
            canclista(q);
            q = t;
         }
         else
            q = succlista(q);
      }
      p = succlista(p);
   }
}

template<class posizione, class tipoelem>
void lista<posizione, tipoelem>::naturalmergesort()
{
   int numerocatene;
   lista<posizione, tipoelem> A, B, L;
   do
   {
      A.crealista();
      B.crealista();
      distribuisci(&A, &B);
      numerocatene = 0;
      crealista();
      merge(A, B, &L, &numerocatene);
   }while(numerocatene != 1)
}

template<class posizione, tipoelem>
void lista<posizione, tipoelem>::distribuisci(lista<posizione, tipoelem> &A, lista<posizione, tipoelem> &B)
{
   posizione p = primolista();
   posizione pa = A.primolista();
   posizione pb = B.primolista();
   do
   {
      copiacatena(&p, this, &pa, &A);
      if(!finelista(p))
         copiacatena(&p, this, &pb, &B);
   }while(!finelista(p)
}

template<class posizione, class tipoelem>
void lista<posizione, tipoelem>::copiacatena(posizione &p, lista<posizione, tipoelem> L, posizione &pa, lista<posizione, tipoelem> &A)
{
   bool finecatena = false;
   do
      copia(&p, this, &pa, &A, &finecatena);
   while(!finecatena)
}

template<class posizione, class tipoelem>
void lista<posizione, tipoelem>::copia(posizione &p, lista<posizione, tipoellem> L, posizione &pa, lista<posizione, tipoelem> &a, bool &finecatena)
{
   tipoelem elemento = leggilista(p);
   A.inslista(pa, elemento);
   p = succlista(p);
   pa = succlista(pa);
   if(finelista(p)
      finecatena = true;
   else
      finecatena = (elemento > leggilista(p));
}

template<class posizione, class tipoelem>
void lista<posizione, tipoelem>::merge(lista<posizione, tipoelem> A, lista<posizione, tipoelem> B, lista<posizione, tipoelem> &L, int &numcatene)
{
   posizione p = primolista();
   posizione pa = A.primolista();
   posizione pb = B.primolista();
   
   while(!A.finelista(pa) && !B.finelista(pb))
   {
      fondicatena(&pa, A, &pb, B, &p, &L)
      numcatene++;
   }
   while(!A.finelista(pa))
   {
      copiacatena(&pa, A, &p, &L);
      numcatene++;
   }
   while(!B.finelista(pb))
   {
      copiacatena(&pb, B, &p, &L);
      numcatene++;
   }
}
listap.h
codice:
#ifndef _listap_h
#define _listap_h

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

using namespace std;

template<class tipoelem>
class listap : public lista<tipoelem>
{
   public:
      typedef nodo<tipoelem> *posizione;    //tipo posizione
           
      listap();                             //costruttore di default
      void crealista();                     //crea la lista vuota
      bool listavuota();                    //stabilisce se la lista è vuota o meno
      posizione primolista();               //restituisce la posizione del primo elemento della lista
      bool finelista(posizione);            //stabilisce se il nodo è l'ultimo della lista
      tipoelem leggilista(posizione);       //restituisce l'elemento della posizione specificata
      posizione succlista(posizione);       //restituisce la posizione del nodo successivo 
      posizione predlista(posizione);       //restituisce la posizione del nodo precedente
      void scrivilista(posizione, tipoelem);//scrive l'elemtno nel nodo specificato dalla posizione
      void inslista(posizione &, tipoelem); //inserisce un nodo e scrive l'elemento nella posizione specificata 
      void canclista(posizione &);          //elimina il nodo nella posizione specificata
   private:
      nodo<tipoelem> cella;                 //nodo della lista (nodo sentinella)
};

#endif

template<class tipoelem>
listap<tipoelem>::listap()
{
   crealista();                             //il costruttore invoca il metodo crealista
}

template<class tipoelem>
void listap<tipoelem>::crealista()
{
   cella.setprec(&cella);
   cella.setsuc(&cella);
   cella.setelem(0);
}

template<class tipoelem>
bool listap<tipoelem>::listavuota()
{
   return((cella.getprec() == &cella) && (cella.getsuc() == &cella));
}

template<class tipoelem>
typename listap<tipoelem>::posizione listap<tipoelem>::primolista()
{
   return(cella.getsuc());
}

template<class tipoelem>
bool listap<tipoelem>::finelista(typename listap<tipoelem>::posizione pos)
{
   return(pos->getsuc() == &cella);
}

template<class tipoelem>
tipoelem listap<tipoelem>::leggilista(typename listap<tipoelem>::posizione pos)
{
   return(pos->getelem());
}

template<class tipoelem>
void listap<tipoelem>::scrivilista(typename listap<tipoelem>::posizione pos, tipoelem elem)
{
   pos->setelem(elem);
}

template<class tipoelem>
typename listap<tipoelem>::posizione listap<tipoelem>::succlista(typename listap<tipoelem>::posizione pos)
{
   return(pos->getsuc());
}

template<class tipoelem>
typename listap<tipoelem>::posizione listap<tipoelem>::predlista(typename listap<tipoelem>::posizione pos)
{
   return(pos->getprec());
}

template<class tipoelem>
void listap<tipoelem>::inslista(typename listap<tipoelem>::posizione &pos, tipoelem elem)
{
   posizione temp = new nodo<tipoelem>;
   
   temp->setprec(pos->getprec());
   temp->setsuc(pos);
   (pos->getprec())->setsuc(temp);
   pos->setprec(temp);
   temp->setelem(elem);
   pos = temp;
}

template<class tipoelem>
void listap<tipoelem>::canclista(typename listap<tipoelem>::posizione &pos)
{
   posizione temp = pos;
   (pos->getsuc())->setprec(pos->getprec());
   (pos->getprec())->setsuc(pos->getsuc());
   pos = pos->getsuc();
   delete temp;
}
testlistap.cpp
codice:
#include "lista.h"
#include "listap.h"
#include <iostream>
#include <stdlib.h>

using namespace std;

int main()
{
   listap<int> list;
   listap<int>::posizione pos = list.primolista();
   
   cout << "popolamento della lista con 10 elementi\n";
   for(int i = 1; i < 10; i++)
   {
      list.inslista(pos, i);
      pos = list.succlista(pos);
   }
   system("pause");
   
   cout << "\n\nvisualizzazione degli elementi della lista e del primo elemento della lista\n";
   pos = list.primolista();
   int i = 1;
   while(pos != list.predlista(list.primolista()))
   {
      cout << "elemento " << i++ << "\t";
      cout << pos << "\t";
      cout << list.predlista(pos) << " " << list.leggilista(pos) << " " << list.succlista(pos) << "\n";
      pos = list.succlista(pos);
   }
   cout << "\n\n" << list.primolista() << "\n";
   system("pause");
   
   cout << "\n\neliminazione del primo elemento e visualizzazione della lista\n";
   pos = list.primolista();
   list.canclista(pos);
   while(pos != list.predlista(list.primolista()))
   {
      cout << list.predlista(pos) << " " << list.leggilista(pos) << " " << list.succlista(pos);
      cout << "\tfinelista: " <<list.finelista(pos) << "\n";
      pos = list.succlista(pos);
   }
   cout << list.primolista() << "\n";
   system("pause");
   
   cout << "\n\neliminazione di tutti gli elementi della lista\n";
   pos = list.primolista();
   while(pos != list.predlista(list.primolista()))
   {
      cout << pos << "\n";
      list.canclista(pos);
      system("pause");
   }
      
   list.canclista(pos);
   cout << list.primolista() << "\n\n";
   system("pause");
   
   if(list.listavuota())
      cout << "\n\nla lista e' vuota!!!\n\n";
   
   system("pause");
   return 0;
}
l'errore che mi viene dato quando compilo il codice cpp è il seguente:

20 C:\Dev-Cpp\esercizi\Lista\lista.h `scrivilista' declared as a `virtual' field
20 C:\Dev-Cpp\esercizi\Lista\lista.h expected `;' before '(' token

a cosa è dovuto??? vi prego rispondete!!!