ciao a tutti, ho implementato la struttura dati grafo con la lista delle adiacenze. nel metodo insarco c'è un'istruzione che dà errore. posto il codice del metodo:

grafola.h
codice:
#ifndef grafolla_h
#define grafolla_h

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

using namespace std;

template<class tipoelem>
class grafolla
{
   public:
      typedef struct nodoad
      {
         char etichetta[15];
         int cursore;
         int peso;
      } adiacente;
      
      typedef struct Nodo
      {
         char etichetta[15];
         int posizione;
         tipoelem valore;
         listap<struct nodoad> *adiacent;
      } nodo;
      
      grafolla();
      
      void creagrafo();
      bool grafovuoto();
      void insnodo(nodo);
      void insarco(nodo, nodo);
      void cancnodo(nodo);
      void cancarco(nodo, nodo);
      listap<struct Nodo> adiacenti(nodo);
      bool esistenodo(nodo);
      bool esistearco(nodo, nodo);
      tipoelem legginodo(nodo);
      void scrivinodo(nodo, tipoelem);
      int leggiarco(nodo, nodo);
      void scriviarco(nodo, nodo, int);
   private:
      nodo *nodi;
      int numnodi;
};

#endif

template<class tipoelem>
grafolla<tipoelem>::grafolla()
{
   this->creagrafo();
}

template<class tipoelem>
void grafolla<tipoelem>::creagrafo()
{
   nodi = NULL;
   numnodi = 0;
}

template<class tipoelem>
bool grafolla<tipoelem>::grafovuoto()
{
   return(numnodi == 0);
}

template<class tipoelem>
void grafolla<tipoelem>::insnodo(typename grafolla<tipoelem>::nodo node)
{
   //assert(!this->esistenodo(node));
   
   numnodi++;
   nodo *noditmp = new struct Nodo[numnodi];
   if(numnodi > 1)
   {
      for(int i = 0; i < numnodi - 1; i++)
         noditmp[i] = nodi[i];
      delete[] nodi;
   }
   cout << "inserire l'etichetta del nodo: ";
   cin >> node.etichetta;
   cout << "inserire il valore del nodo: ";
 
   cin >> node.valore;
   node.adiacent = NULL;
   node.posizione = numnodi - 1;
   noditmp[numnodi - 1] = node;
   nodi =  noditmp;
}  

template<class tipoelem>
void grafolla<tipoelem>::insarco(typename grafolla<tipoelem>::nodo n1, typename grafolla<tipoelem>::nodo n2)
{
   assert(this->esistenodo(n1) && this->esistenodo(n2) && !this->esistearco(n1, n2));
   
   adiacente a;
   a.etichetta = n2.etichetta;
   a.cursore = n2.posizione;
   listap<struct nodoad> *l = nodi[n1.posizione].adiacent;
   l->inslista(l->predlista(l->primolista()), a);
}

template<class tipoelem>
void grafolla<tipoelem>::cancnodo(typename grafolla<tipoelem>::nodo node)
{
   assert(this->esistenodo(node));
   
   //eliminazione degli archi (adiacenze) uscenti
   bool trovato = false;
   int i = 0;
   while(!trovato)
   {
      if(nodi[i].etichetta == node.etichetta)
      {
         listap<struct nodoad> *l = nodi[i].adiacent;
         while(!l->listavuota())
            l->canclista(l->primolista());
         trovato = true;
      }
      else
         i++;
   }
   
   //eliminazione degli archi (adiacenze) entranti
   for(int k = 0; k < numnodi; k++)
   {
      if(this->esistearco(nodi[k], node))
         this->cancarco(nodi[k], node);
      else
         k++;
   }
   
   //modifica del vettore dei nodi
   nodo *noditmp = new struct Nodo[numnodi - 1];
   int j;
   for(j = 0; j < i; j++)
      noditmp[j] = nodi[j];
   j = i + 1;
   for(j = i + 1; j < (numnodi - 1); j++)
   {
      noditmp[j - 1] = nodi[j];
      noditmp[j - 1].posizione -= 1;
   }
   nodi = noditmp;
   
   numnodi -= 1;
}

template<class tipoelem>
void grafolla<tipoelem>::cancarco(typename grafolla<tipoelem>::nodo n1, typename grafolla<tipoelem>::nodo n2)
{
   assert(this->esistenodo(n1) && this->esistenodo(n2) && this->esistearco(n1, n2));
   
   listap<struct nodoad> *l = nodi[n1.posizione].adiacent;
   typename listap<struct nodoad>::posizione p = l->primolista();
   bool trovato = false;
   while(!trovato && (p != l->predlista(l->primolista())))
   {
      if(l->leggilista(p).etichetta == n2.etichetta)
      {
         l->canclista(p);
         trovato = true;
      }
      else
         p = l->suclista(p);
   }
}

template<class tipoelem>
listap<typename grafolla<tipoelem>::nodo> grafolla<tipoelem>::adiacenti(typename grafolla<tipoelem>::nodo node)
{
   assert(this->esistenodo(node));
   
   listap<struct Nodo> lis;
   if(nodi[node.posizione].adiacent != NULL)
   {
      listap<nodoad> l = *nodi[node.posizione].adiacent;
      typename listap<nodoad>::posizione p = l.primolista();
      while(p != l.predlista(l.primolista()))
      {
         lis.inslista(lis.predlista(lis.primolista()), nodi[l.leggilista(p).cursore]);
         p = l.suclista(p);
      }
   }
   
   return lis;
}

template<class tipoelem>
bool grafolla<tipoelem>::esistenodo(typename grafolla<tipoelem>::nodo node)
{
   bool esito = false;
   int i = 0;
   while(!esito && (i < numnodi))
   {
      if(nodi[i].etichetta == node.etichetta)
         esito = true;
      else
         i++;
   }
   
   return esito;
}

template<class tipoelem>
bool grafolla<tipoelem>::esistearco(typename grafolla<tipoelem>::nodo n1, typename grafolla<tipoelem>::nodo n2)
{
   assert(this->esistenodo(n1) && this->esistenodo(n2));
   
   listap<nodoad> *l = nodi[n1.posizione].adiacent;
   typename listap<nodoad>::posizione p = l.primolista();
   bool trovato = true;
   while(!trovato && (p != l->predlista(l->primolista())))
   {
      if(l->leggilista(p).etichetta == nodi[n2.posizione].etichetta)
         trovato = true;
      else
         p = l->suclista(p);
   }
   
   return trovato;
}

template<class tipoelem>
tipoelem grafolla<tipoelem>::legginodo(typename grafolla<tipoelem>::nodo node)
{
   assert(this->esistenodo(node));
   
   return(nodi[node.posizione].valore);
}

template<class tipoelem>
void grafolla<tipoelem>::scrivinodo(typename grafolla<tipoelem>::nodo node, tipoelem elem)
{
   assert(this->esistenodo(node));
   
   nodi[node.posizione].valore = elem;
}

template<class tipoelem>
int grafolla<tipoelem>::leggiarco(typename grafolla<tipoelem>::nodo n1, typename grafolla<tipoelem>::nodo n2)
{
   assert(this->esistearco(n1, n2));
   
   listap<nodoad> *l = nodi[n1.posizione].adiacent;
   typename listap<nodoad>::posizione p = l->primolista();
   bool trovato = false;
   
   while(!trovato && (p != l->predlista(l->primolista())))
   {
      if(l->leggilista(p).etichetta == n2.etichetta)
         trovato = true;
      else
         p = l->suclista(p);
   }
   
   return(l->leggilista(p).peso);
}

template<class tipoelem>
void grafolla<tipoelem>::scriviarco(typename grafolla<tipoelem>::nodo n1, typename grafolla<tipoelem>::nodo n2, int pes)
{
   assert(!this->esistearco(n1, n2));
   
   listap<nodoad> *l = nodi[n1.posizione].adiacent;
   typename listap<nodoad>::posizione p = l->primolista();
   bool trovato = false;
   
   while(!trovato && (p != l->predlista(l->primolista())))
   {
      if(l->leggilista(p).etichetta == n2.etichetta)
      {
         nodoad n = l->leggilista(p);
         n.peso = pes;
         l->scrivilista(p, n);
         trovato = true;
      }
      else
         p = l->suclista(p);
   }
}
l'errore che mi viene visualizzato è il seguente:

101 C:\Dev-Cpp\Strutture\Grafi\grafolla.h ISO C++ forbids assignment of arrays

perchè??? da quando in qua è proibito fare un assegnamento in un campo di un record??