[C++] Variabile non riconosciuta

[lacchiappasogni]

Salve,
ho un errore al quale non trovo soluzione. Ho dichiarato una classe di tipo nodo e dopo di che ho definito un vettore di nodi. Ma non mi viene riconosciuta. L'errore segnalato è il seguente: "In file included from testl.cpp / ISO C++ forbids declaration of `nodo' with no type / expected `;' before '<' token"
Chi è così gentile da aiutarmi?

Eccovi i codici:
classe nodo

#ifndef nodo_h 
#define nodo_h
#include <iostream>
#include <stdlib.h>

using namespace std;

template<class T>

class nodo 

{
 public:
        nodo();
        void scrivielem(T);
        T leggielem();
        void scriviprec(nodo*);
        void scrivisucc(nodo*);
        nodo* leggiprec();
        nodo* leggisuc();
        
        
 private:
         T elemento;
         nodo *precedente;
         nodo *successivo;
      
};
#endif
      
template<class T> // COSTRUTTORE
nodo<T>::nodo() 
{
  elemento= 0;
  precedente=NULL;
  successivo=NULL;
}
 
 
template<class T> //SCRIVIELEM
void nodo<T>::scrivielem(T elem)
{
  elemento=elem;
}
 
template<class T> // LEGGIELEM
T nodo<T>::leggielem()
{
  return (elemento);
}
 
template<class T> //SCRIVISUCC
void nodo<T>::scrivisucc (nodo* succ)
{
  successivo=succ;
}
 
template<class T> //SCRIVIPREC
void nodo<T>::scriviprec (nodo* prec)
{
  precedente=prec;        
}
            
template<class T> //LEGGIPREC
nodo<T>::nodo<T>* nodo<T>::leggiprec()
{
  return(precedente);
}          
        
template<class T> //LEGGISUC
nodo<T>::nodo<T>* nodo<T>::leggisuc()
{
  return (successivo);
}

lista

#ifndef listavet_h
#define listavet_h 

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

using namespace std;

template <class tipoelem>
class listavet : public lista<tipoelem, int>
{   
      public:
             
             typedef int posizione;
             listavet(int); 
             void crealista();
             bool listavuota();
             tipoelem leggilista(posizione);
             void scrivilista(tipoelem, posizione);
             posizione primolista();
             bool finelista(posizione);
             posizione succlista(posizione);
             posizione preclista(posizione);
             void inslista(tipoelem, posizione);
             void canclista(posizione);
      private:
            nodo<tipoelem> *vettore;
            int maxdim;
            int lunglista;
      };
#endif
      

template <class tipoelem> //costruttore
listavet <tipoelem>::listavet(int dimensione) 
{
  maxdim=dimensione;    
  crealista();
}
         
template <class tipoelem> //crealista
void listavet <tipoelem>::crealista() 
{
  vettore=new nodo<tipoelem>[maxdim];
  lunglista=0;         
}
         
template <class tipoelem> //listavuota
bool listavet<tipoelem>::listavuota() 
{
  return (lunglista == 0);
}
     
template <class tipoelem> //primolista
typename listavet<tipoelem>::posizione listavet<tipoelem>::primolista()
{
  return (0);
}
     
template <class tipoelem> //leggilista
tipoelem listavet<tipoelem>::leggilista(typename listavet<tipoelem>::posizione p)
{ 
  assert ( (p>=0) && (p<lunglista) && (!listavuota()) ); 
  return (vettore[p].leggielem());
}

template <class tipoelem> //scrivilista
void listavet<tipoelem>::scrivilista(tipoelem elem, typename listavet<tipoelem>::posizione p)
{
 assert ((p>=0)&&(p<=lunglista));
 vettore[p].scrivielem(elem);
}
     
template <class tipoelem> // finelista
bool listavet<tipoelem>::finelista(typename listavet<tipoelem>::posizione p) 
{
 assert ((p>=0)&&(p<=(lunglista)));
 return(p==lunglista); 
}
     
     
template <class tipoelem> //succlista
typename listavet<tipoelem>::posizione listavet<tipoelem>::succlista(typename listavet<tipoelem>::posizione p) 
{
  assert((p>=0)&&(p<(lunglista)));     
  return (p+1);
}
         
template <class tipoelem> //preclista
typename listavet<tipoelem>::posizione listavet<tipoelem>::preclista(typename listavet<tipoelem>::posizione p)
{
 assert((p>=1)&&(p<=lunglista));
 return (p-1);
 
}
         
template <class tipoelem> // inslista
void listavet<tipoelem>::inslista(tipoelem elem, typename listavet<tipoelem>::posizione p) 
{ 
  assert ((p>=0)&&(p<=lunglista));
  if (maxdim>lunglista)
    {
      for (int i=lunglista;i>p;i--)
      vettore[i]=vettore[i-1];
           
      vettore[p].scrivielem(elem);
      lunglista++;
    }
}

template <class tipoelem> //canclista
void listavet<tipoelem>::canclista(typename listavet<tipoelem>::posizione p) 
{
  assert ((p>=0)&&(p<lunglista));
  if (p<lunglista-1)  
    {
      for(int i=p;i<=lunglista;i++)
      vettore[i]=vettore[i+1];
    }       
  lunglista--;  
}

test

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

using namespace std;

int main()
{
  listavet<int> list(10);
  list.testliste();
  
  system ("PAUSE");
  return 0;      
}

[MItaly]

Su che riga ti dà l'errore?

[Who am I]

C'è un errore che fai dappertutto, ad esempio qua:

private:
         T elemento;
         nodo *precedente;
         nodo *successivo;

La classe nodo deve avere un tipo,devi scrivere:

private:
         T elemento;
         nodo<T> *precedente;
         nodo<T> *successivo;