Cast di puntatori per una calsse template

[Beppe2hd]

Ho la seguente calsse template:

template <class pass> class impiegato_dirigente : public impiegato_generale
{
public:
    impiegato_dirigente(string nome_p, int matricola_p, int stipendio_p, int ore_set_p, int grado_p, int extra_prod);
    void varia_grado(int var_grado);
    void varia_extra(int var_extra);
    int get_grado();
    int get_extra_prod();
    pass get_password();

private:
    int grado;
    int extra_prod;
    pass password;
};

Come vedete è una classe derivata.

Il problema è che al contempo uso delle liste ed ecco che scatta il problema perchè avendo piu classi devo usare i puntatori.
Cioè il nodo della lista contiene un puntatore ad un ogetto di quella classe o di altre.
Per accedere ai vare membri uso quindi il seguente codice:

(((impiegato_dirigente<int>)*)(i.get()))->inc_ore_lavorative(ore_set_p);

dove i.get mi restituisce un puntatore all'ogetto che per controli precedenti so essere di tipo classe dirigente.
o usato lo stesso codice con classi non template e funziona solo che in questo caso che la classe è template e quindi vuole anche specificato il tipo devc++ mi restituisce il seguente errore: parse error before ")"

Aiutatemi perchè è l'unico errore rimasto sulle 800 linee di codice circa

Per chiarezza allego l'intero progetto.

[Beppe2hd]

/*************************************
*     Main del mio programma         *
*************************************/
#include <string>
#include <cstdio>

/* Classe impiegato generale*/

class impiegato_generale
{

public:
    impiegato_generale();
    impiegato_generale(string nome_p, int matricola_p, int stipendio_p, int ore_set_p);

    void inc_stipendio(int percentuale);
    void inc_ore_lavorative(int ore_inc);

    string get_nome();
    int get_matricola();
    int get_stipendio();
    int get_ore_set();
    int get_tipo();

private:
    string nome;
    int matricola;
    int stipendio;
    int ore_set;

protected:
    int tipo;
};
    impiegato_generale::impiegato_generale()
    {
    nome="Nulla";
    matricola=0;
    stipendio=0;
    ore_set=0;  
    }
    
    impiegato_generale::impiegato_generale(string nome_p, int matricola_p, int stipendio_p, int ore_set_p)
    {
    nome=nome_p;
    matricola=matricola_p;
    stipendio=stipendio_p;
    ore_set=ore_set_p; 
    }

/*Classe impiegato dirigente*/
template <class pass> class impiegato_dirigente : public impiegato_generale
{
public:
    impiegato_dirigente(string nome_p, int matricola_p, int stipendio_p, int ore_set_p, int grado_p, int extra_prod);
    void varia_grado(int var_grado);
    void varia_extra(int var_extra);
    int get_grado();
    int get_extra_prod();
    pass get_password();

private:
    int grado;
    int extra_prod;
    pass password;
};

template <class pass> impiegato_dirigente<pass> :: impiegato_dirigente(string nome_p, int matricola_p, int stipendio_p, int ore_set_p,int grado_p, int extra_prod_p)
     :impiegato_generale(nome_p, matricola_p, stipendio_p, ore_set_p)
{
tipo=1;
grado=grado_p;
extra_prod=extra_prod_p;
cout<<"Inserisci la password: " ;
cin>>password;
}

/*Impiegato operaio*/

class impiegato_operaio : public impiegato_generale
{

public:
    impiegato_operaio(string nome_p, int matricola_p, int stipendio_p, int ore_set_p,int settore_p, int buoni);
    void varia_settore(int var_settore);
    void varia_buoni(int var_buoni);
    int get_settore();
    int get_buoni();

private:
    int settore;
    int buoni;

};

impiegato_operaio::impiegato_operaio(string nome_p, int matricola_p, int stipendio_p, int ore_set_p,int settore_p, int buoni_p)
     :impiegato_generale(nome_p, matricola_p, stipendio_p, ore_set_p)
{
    tipo=2;
    settore=settore_p;
    buoni=settore_p;  
}


/*Classe impiegato esterno*/

class impiegato_esterno : public impiegato_generale

{
public:
    impiegato_esterno(string nome_p, int matricola_p, int stipendio_p, int ore_set_p, int livello_p, int fiducia_p);
    void varia_livello(int var_livello);
    void varia_fiducia(int var_fiducia);
    int get_fiducia();
    int get_livello();

private:
    int livello;
    int fiducia;
};

impiegato_esterno::impiegato_esterno(string nome_p, int matricola_p, int stipendio_p, int ore_set_p, int livello_p, int fiducia_p)
     :impiegato_generale(nome_p, matricola_p, stipendio_p, ore_set_p)
{
    tipo=3;
    livello=livello_p;
    fiducia=fiducia_p;
}


/*--------------------------------------------------
*       Definizione funzioni    generiche          *
--------------------------------------------------*/

    ostream& operator<<(ostream& out, impiegato_operaio op){
            cout<<"Matricola: " <<op.get_matricola()<<"\n";
            cout<<"Nome: " <<op.get_nome()<<"\n";
            cout<<"Stipendio: " <<op.get_stipendio()<<"\n";
            cout<<"Ore Lavorative: " <<op.get_ore_set()<<"\n";
            cout<<"Settore: " <<op.get_settore()<<"\n";
            cout<<"Buoni: " <<op.get_buoni()<<"\n";
        return out;
    }

    ostream& operator<<(ostream& out, impiegato_esterno est){
            cout<<"\nMatricola: " <<est.get_matricola();
            cout<<"\nNome: " <<est.get_nome();
            cout<<"\nStipendio: " <<est.get_stipendio();
            cout<<"\nOre Lavorative: " <<est.get_ore_set();
            cout<<"\nLivello: " <<est.get_livello();
            cout<<"\nFiducia: " <<est.get_fiducia()<<"\n";
        return out;
    }



    int impiegato_generale::get_tipo()
        {
            return tipo;
        }

    void impiegato_generale::inc_stipendio(int percentuale)
    {
        if((percentuale<-100)||(percentuale>100))
            cout << "Errore\n";
        else
            stipendio=stipendio+(stipendio*((double)percentuale/100.0));
    }

    void impiegato_generale::inc_ore_lavorative(int ore_inc)
        {
            if(ore_inc>4||ore_inc<-4)
            {
                cout<<"Errore\n";
                return;
            }

            int swap_ore_lavorative = ore_set + ore_inc;
            
            if(swap_ore_lavorative < 0 || swap_ore_lavorative > 50)
                cout<<"Le ore lavorative non rientrano nel range 0-50 e perciò non verranno modificate\n";
            else
                ore_set=swap_ore_lavorative;
        }

    string impiegato_generale::get_nome()
        {
            return nome;
        }

    int impiegato_generale::get_matricola()
        {
            return matricola;
        }

    int impiegato_generale::get_stipendio()
        {
            return stipendio;
        }

    int impiegato_generale::get_ore_set()
        {
            return ore_set;
        }

/*--------------------------------------------------
*       Definizione funzioni    dirigente       * 
--------------------------------------------------*/

    template <class pass> void impiegato_dirigente<pass>::varia_grado(int var_grado)
        {
        int swap_grado = grado + var_grado;
        if(swap_grado < 1 || swap_grado > 3)
            cout<<"Errore, il valore non verra' modificato\n";
        else
            grado = swap_grado;
       }

    template <class pass> void impiegato_dirigente<pass>::varia_extra(int var_extra)
        {
        int swap_extra = extra_prod + var_extra;
        if(swap_extra < 1 || swap_extra > 3)
            cout<<"Errore, il valore non verra' modificato\n";
        else
            extra_prod = swap_extra;
       }

    template <class pass> int impiegato_dirigente<pass>::get_grado()
        {
            return grado;
        }

    template <class pass> int impiegato_dirigente<pass>::get_extra_prod()
        {
            return grado;
        }
    template <class pass> pass impiegato_dirigente<pass>::get_password()
        {
            return password;
        }

/*--------------------------------------------------
*       Definizione funzioni    operaio             * 
--------------------------------------------------*/

    void impiegato_operaio::varia_settore(int var_settore)
        {
            if (var_settore!=1 || var_settore!=2 || var_settore!=3)
                cout<<"Errore, il settore selezionato non esiste\n";

            else if(settore==var_settore)
                cout<<"L'operaio appartiene gia al settore " << settore << "\n";
            else
                settore=var_settore;

        }

    void impiegato_operaio::varia_buoni(int var_buoni)
        {
            if (var_buoni!=1 || var_buoni!=2 || var_buoni!=3)
                cout<<"Errore, il buono deve essere 1, 2 o 3\n";

            else if(buoni==var_buoni)
                cout<<"L'operaio ottiene gia il tipo di buono selezionato \n";
            else
                buoni=var_buoni;
        }

    int impiegato_operaio::get_settore()
        {
            return settore;
        }

    int impiegato_operaio::get_buoni()
        {
            return buoni;
        }

/*--------------------------------------------------
*       Definizione funzioni    coll ext       * 
--------------------------------------------------*/

    void impiegato_esterno::varia_livello(int var_livello)
        {
        int swap_livello=livello + var_livello;
        if(swap_livello<1 || swap_livello>3)
            cout<<"Errore, il livello deve essere 1, 2 o 3\n";
        else
            livello = swap_livello;
        }

    void impiegato_esterno::varia_fiducia(int var_fiducia)
        {
        int swap_fiducia=fiducia + var_fiducia;
        if(swap_fiducia<1 || swap_fiducia>3)
            cout<<"Errore, la fiducia deve essere 1, 2 o 3\n";
        else
            fiducia = swap_fiducia;
        }

    int impiegato_esterno::get_fiducia()
        {
            return fiducia;
        }

    int impiegato_esterno::get_livello()
        {
            return livello;
        }
/****************************************************************************************************************************************
*****************************************************************************************************************************************
*****************************************************************************************************************************************
******************************************************************************************************************************************/


/************************************************
*           Codice sulle liste                  *
************************************************/
#include <string>
#include <iostream>
#include <cassert>

using namespace std;

class List;
class Iterator;

class Node
{
public:
   Node(void* s);
private:
   void* data;
   Node* previous;
   Node* next;
friend class List;
friend class Iterator;
};

class List
{
public:
   List();
   void push_back(void* s);
   void insert(Iterator iter, void* s);
   Iterator erase(Iterator i);
   Iterator begin();
   Iterator end();
private:
   Node* first;
   Node* last;
};

class Iterator
{
public:
   Iterator();
   void* get() const;
   void next();
   void previous();
   bool equals(Iterator b) const;
private:
   Node* position;
   Node* last;
friend class List;
};

Node::Node(void* s)
{  
   data = s;
   previous = NULL;
   next = NULL;
}

List::List()
{  
   first = NULL;
   last = NULL;
}

void List::push_back(void* s)
{  
   Node* newnode = new Node(s);
   if (last == NULL) /* la lista è vuota */
   {  
      first = newnode;
      last = newnode;
   }
   else
   {  
      newnode->previous = last;
      last->next = newnode;
      last = newnode;
   }
}

void List::insert(Iterator iter, void* s)
{  
   if (iter.position == NULL)
   {  
      push_back(s);
      return;
   }

   Node* after = iter.position;
   Node* before = after->previous;
   Node* newnode = new Node(s);
   newnode->previous = before;
   newnode->next = after;
   after->previous = newnode;
   if (before == NULL) /* inserire all’inizio */
      first = newnode;
   else
      before->next = newnode;
}

Iterator List::erase(Iterator i)
{  
   Iterator iter = i;
   assert(iter.position != NULL);
   Node* remove = iter.position;
   Node* before = remove->previous;
   Node* after = remove->next;
   if (remove == first)
      first = after;
   else
      before->next = after;
   if (remove == last)
      last = before;
   else
      after->previous = before;
   iter.position = after;
   delete remove;
   return iter;
}

Iterator List::begin()
{  
   Iterator iter;
   iter.position = first;
   iter.last = last;
   return iter;
}

Iterator List::end()
{  
   Iterator iter;
   iter.position = NULL;
   iter.last = last;
   return iter;
}

Iterator::Iterator()
{  
   position = NULL;
   last = NULL;
}

void* Iterator::get() const
{  
   assert(position != NULL);
   return position->data;
}

void Iterator::next()
{  
   assert(position != NULL);
   position = position->next;
}

void Iterator::previous()
{  
   if (position == NULL)
      position = last;
   else 
      position = position->previous;
   assert(position != NULL);
}

bool Iterator::equals(Iterator b) const
{  
   return position == b.position;
}









/****************************************************************************************************************************************
*****************************************************************************************************************************************
*****************************************************************************************************************************************
******************************************************************************************************************************************/




void stampa_lista();
void aggiungi_impiegato();
void modifica_impiegato(int mat);
void elimina_impiegato(int mat);

List impiegati;

void main(){
       int a=0;
       impiegati = *(new List());

       while(a!=5)
       {
           cout<<"1) Per stampare la lista degli impiegati\n";                    
           cout<<"2) Per aggiungere un nuovo impiegato in coda\n";
           cout<<"3) Per modificare i parametri di un impiegato\n";
           cout<<"4) Per eliminare un impiegato\n";
           cout<<"5) Per terminare il programma\n";   
           cin>>a;

              switch(a){
                  case 1:
                       stampa_lista();
                  break;
                  case 2:
                       aggiungi_impiegato();
                  break;
                  case 3:
                       int mat_da_modificare;
                        cout<<"Inserisci la matricola dell'impiegato di cui modiicare i parametri\n";
                        cin>>mat_da_modificare;
                        modifica_impiegato(mat_da_modificare);
                  break;
                  case 4:
                       int mat_da_eliminare;
                        cout<<"Inserisci la matricola dell'impiegato da eliminare\n";
                        cin>>mat_da_eliminare;
                        elimina_impiegato(mat_da_eliminare);
                  break;
                  case 5:
                       return 0;
                  break;
                  default:
                       cout<<"Errore, il valore inserito non è corretto\n\n";
                  break;
              }
     }
}
/************************************
*  Funzioni del menu principale     *
************************************/


void stampa_lista(){
    Iterator st=impiegati.begin();

    while(!st.equals(impiegati.end())){
        if(((impiegato_generale*)(st.get()))->get_tipo()==2){
            cout<<(*(impiegato_operaio*)(st.get()));
        }
        else if(((impiegato_generale*)(st.get()))->get_tipo()==3){
            cout<<(*(impiegato_esterno*)(st.get()));
        }
        else if(((impiegato_generale*)(st.get()))->get_tipo()==1){
            cout<<"Matricola: " <<(((impiegato_dirigente<int>)*)(st.get()))->get_matricola()<<"\n";
            cout<<"Nome: " <<(((impiegato_dirigente<int>)*)(st.get()))->get_nome()<<"\n";
            cout<<"Stipendio: " <<(((impiegato_dirigente<int>)*)(st.get()))->get_stipendio()<<"\n";
            cout<<"Ore Lavorative: " <<(((impiegato_dirigente<int>)*)(st.get()))->get_ore_set()<<"\n";
            cout<<"Grado: " <<(((impiegato_dirigente<int>)*)(st.get()))->get_grado()<<"\n";
            cout<<"Extra: " <<(((impiegato_dirigente<int>)*)(st.get()))->get_extra_prod()<<"\n";
            cout<<"Password: " <<(((impiegato_dirigente<int>)*)(st.get()))->get_password()<<"\n";
        }
        st.next();
    }
}

void aggiungi_impiegato(){
     int b=0;  /*Variabile di appoggio*/
     cout<<"Specificare il tipo di impiegato da inserire\n";
     cout<<"1) Dirigente\n2) Operaio\n3) Collaboratore esterno\n\n-->";
     cin>>b;

     if(b==1)         /*Inserisco un dirigente*/
     {
                      string nome_p;
                      int matricola_p;
                      int stipendio_p;
                      int ore_set_p;
                      int grado_p;
                      int extra_prod_p; 
                      int password_type;

                      cout<<"Inserisci il nome del nuovo impiegato\n"; 
                      cin>>nome_p;  
                      cout<<"Inserisci la matricola\n"; 
                      cin>>matricola_p;
                      cout<<"Inserisci lo stipendio\n"; 
                      cin>>stipendio_p;
                      cout<<"Inserisci le ore lavorative\n"; 
                      cin>>ore_set_p; 
                      cout<<"Inserisci il grado con un numero compreso tra 1 e 3\n"; 
                      cin>>grado_p; 
                      cout<<"Inserisci gli extra produttivi con un numero compreso tra 1 e 3\n"; 
                      cin>>extra_prod_p; 
                      cout<<"Inserisci il tipo di password:\n1) Numerica \n2) Caratteri\n";
                      cin>>password_type;
                      
                      /*Dato tutto questo devo ora generare l'impiegato come un nuovo oggetto*/
                      impiegato_dirigente<char>* a;
                      impiegato_dirigente<int>* b;

                      if(password_type==1){
                      a = new impiegato_dirigente<char>(nome_p, matricola_p, stipendio_p, ore_set_p, grado_p, extra_prod_p);
                      impiegati.push_back(a);
                      }
                      else{
                      b = new impiegato_dirigente<int>(nome_p, matricola_p, stipendio_p, ore_set_p, grado_p, extra_prod_p);
                      impiegati.push_back(b);
                      }
             }
             
     else if(b==2)   /*Inserisco un operaio*/
          {                        
                                      
                      string nome_p;
                      int matricola_p;
                      int stipendio_p;
                      int ore_set_p; 
                       int settore_p;
                      int buoni_p;
                      cout<<"Inserisci il nome del nuovo impiegato\n"; 
                      cin>>nome_p;  
                      cout<<"Inserisci la matricola\n"; 
                      cin>>matricola_p;
                      cout<<"Inserisci lo stipendio\n"; 
                      cin>>stipendio_p;
                      cout<<"Inserisci le ore lavorative\n"; 
                      cin>>ore_set_p;
                      cout<<"Inserisci il settore con un valore tra 1 e 3\n"; 
                      cin>>settore_p; 
                      cout<<"Inserisci il valore dei buoni con un numero tra 1 e 3\n"; 
                      cin>>buoni_p;  
                      
                      /*Dato tutto questo devo ora generare l'impiegato come un nuovo ogetto*/
                      impiegato_operaio* a = new impiegato_operaio(nome_p, matricola_p, stipendio_p, ore_set_p, settore_p, buoni_p);
                      impiegati.push_back(a);
                      
                      
          }
     
     else if(b==3)   /*Inserisco un collabortore esterno*/
          {
                                      
                      string nome_p;
                      int matricola_p;
                      int stipendio_p;
                      int ore_set_p; 
                      int grado_p;
                      int fiducia_p;
                      cout<<"Inserisci il nome del nuovo impiegato\n"; 
                      cin>>nome_p;  
                      cout<<"Inserisci la matricola\n"; 
                      cin>>matricola_p;
                      cout<<"Inserisci lo stipendio\n"; 
                      cin>>stipendio_p;
                      cout<<"Inserisci le ore lavorative\n"; 
                      cin>>ore_set_p;
                      cout<<"Inserisci il livello con un valore tra 1 e 3\n"; 
                      cin>>grado_p;
                      cout<<"Inserisci il livello di fiducia con un numero tra 1 e 3\n"; 
                      cin>>fiducia_p;
                      
                      /*Dato tutto questo devo ora generare l'impiegato come un nuovo ogetto*/
                      impiegato_esterno* a = new impiegato_esterno(nome_p, matricola_p, stipendio_p, ore_set_p, grado_p, fiducia_p);
                      impiegati.push_back(a);
                      
          }
     else
         cout<<"Hai sbagliato inserendo un valore non corretto\n\n";
}
     
void modifica_impiegato(int mat_da_modificare)
{
     /*cout<<"\n****modificaImpiegato****\n"*/

     /*Codice che richiama l'elemento della lista relativo alla matricola */
     int matr = 0;
     Iterator i = impiegati.begin();

     while(!(i.equals(impiegati.end()))){
         matr = ((impiegato_generale*)(i.get()))->get_matricola();
         if(matr = mat_da_modificare)
                 break;
         i.next();
     }

     if(((impiegato_generale*)(i.get()))->get_tipo()==1)
     {
                      cout<<"Quale parametro vuoi modificare?\n\n";
                      int modifica;
                      int stipendio_p;
                      int ore_set_p;
                      int grado_p;
                      int extra_prod_p; 
                      cout<<"1) Modifica lo stipendio\n"; 
                      cout<<"2) Modifica le ore lavorative\n"; 
                      cout<<"3) Modifica il grado con un numero compreso tra 1 e 3\n"; 
                      cout<<"4) Modifica gli extra produttivi con un numero compreso tra 1 e 3\n\n-->";
                      cin>>modifica;
                      
                      if(modifica==1) {
                          cout<<"Inserisci la percentuale di modifica\n";
                          cin>>stipendio_p;
                          (        ((impiegato_dirigente<int>)*)          (i.get())      )       ->inc_stipendio(stipendio_p);
                      }
                      else if(modifica==2){
                          cout<<"Inserisci l'incremento di ore lavorative\n";
                          cin>>ore_set_p;
                          (((impiegato_dirigente<int>)*)(i.get()))->inc_ore_lavorative(ore_set_p);
                      }
                      else if(modifica==3){
                          cout<<"Inserisci la variazione grado con un numero compreso tra 1 e 3\n";
                          cin>>grado_p;
                          (  ((impiegato_dirigente<int>)*)   (i.get())  )->varia_grado(grado_p);
                      }
                      else if (modifica==4){
                          cout<<"Inserisci la variazione degli extra produttivi con un numero compreso tra 1 e 3\n";
                          cin>>extra_prod_p;
                          (((impiegato_dirigente<int>)*)(i.get()))->varia_extra(extra_prod_p);
                      }
     }
     
     
     
     /*Codice che richiama l'elemento della lista relativo a */
     
     else if(((impiegato_generale*)(i.get()))->get_tipo()==2)
     {
                  cout<<"Quale parametro vuoi modificare?\n\n";
                     int modifica;
                      int stipendio_p;
                      int ore_set_p;
                      int settore_p;
                      int buoni_p; 
                      cout<<"1) Modifica lo stipendio\n"; 
                      cout<<"2) Modifica le ore lavorative\n"; 
                      cout<<"3) Modifica il settore con un numero compreso tra 1 e 3\n"; 
                      cout<<"4) Modifica i buoni con un numero compreso tra 1 e 3\n"; 
                      cin>>modifica;

                      if(modifica==1) {
                          cout<<"Inserisci la percentuale di modifica\n";
                          cin>>stipendio_p;
                          ((impiegato_operaio*)(i.get()))->inc_stipendio(stipendio_p);
                      }
                      else if(modifica==2){
                          cout<<"Inserisci l'incremento di ore lavorative\n";
                          cin>>ore_set_p;
                          ((impiegato_operaio*)(i.get()))->inc_ore_lavorative(ore_set_p);
                      }
                      else if(modifica==3){
                          cout<<"Inserisci la variazione grado con un numero compreso tra 1 e 3\n";
                          cin>>settore_p;
                          ((impiegato_operaio*)(i.get()))->varia_settore(settore_p);
                      }
                      else if (modifica==4){
                          cout<<"Inserisci la variazione degli extra produttivi con un numero compreso tra 1 e 3\n";
                          cin>>buoni_p;
                          ((impiegato_operaio*)(i.get()))->varia_buoni(buoni_p);
                      }
     }
     
     
     /*Codice che richiama l'elemento della lista relativo a */
     
     else if(((impiegato_generale*)(i.get()))->get_tipo()==3)
     {
                     cout<<"Quale parametro vuoi modificare?\n\n";
                     int modifica;
                      int stipendio_p;
                      int ore_set_p;
                      int livello_p;
                      int fiducia_p; 
                      cout<<"1) Modifica lo stipendio\n"; 
                      cout<<"2) Modifica le ore lavorative\n"; 
                      cout<<"3) Modifica il livello con un numero compreso tra 1 e 3\n"; 
                      cout<<"4) Modifica la fiducia con un numero compreso tra 1 e 3\n"; 
                      cin>>modifica;

                      if(modifica==1) {
                          cout<<"Inserisci la percentuale di modifica\n";
                          cin>>stipendio_p;
                          ((impiegato_esterno*)(i.get()))->inc_stipendio(stipendio_p);
                      }
                      else if(modifica==2){
                          cout<<"Inserisci l'incremento di ore lavorative\n";
                          cin>>ore_set_p;
                          ((impiegato_esterno*)(i.get()))->inc_ore_lavorative(ore_set_p);
                      }
                      else if(modifica==3){
                          cout<<"Inserisci la variazione grado con un numero compreso tra 1 e 3\n";
                          cin>>livello_p;
                          ((impiegato_esterno*)(i.get()))->varia_livello(livello_p);
                      }
                      else if (modifica==4){
                          cout<<"Inserisci la variazione degli extra produttivi con un numero compreso tra 1 e 3\n";
                          cin>>fiducia_p;
                          ((impiegato_esterno*)(i.get()))->varia_fiducia(fiducia_p);
                      }
     }
}
     
     
void elimina_impiegato(int mat_da_eliminare)
{
     bool trovato = false;
      Iterator el=impiegati.begin();
      while(!(el.equals(impiegati.end()))){
         if (((impiegato_generale*)(el.get()))->get_matricola()==mat_da_eliminare){
            impiegati.erase(el);
            trovato = true;
            break;
         }
         el.next();
      }

if(trovato==true)
cout<<"L'impiegato è stato eliminato con successo\n\n";
else
cout<<"La matricola non è presente\n";
     
     
     }