[C++]Errore compilazione costruttore copia

[mx92]

Ciao a tutti...Per esercizio sto realizzando una classe per la gestione di una lista concatenata con sentinella. Sto avendo dei problemi nella costruzione del costruttore di copia.
Ecco il file header

#include "Nodo.h"
#include <iostream>


template<typename Tipo> 
class Lista
{
    private:
        Nodo<Tipo>* InizioLista;
        Nodo<Tipo>*    Current;
        
    public:
        Lista();
        Lista(const Lista<Tipo> &lista);
        
        bool ListaVuota();
        bool FineLista() const;
        
        int DimensioneLista(Lista<Tipo>* = NULL);
        int PosizioneCursore(Lista<Tipo>* = NULL);
        
        void InserisciInCoda(Tipo, Lista<Tipo>* = NULL);
        void InserisciInPosizione(Tipo, int, Lista<Tipo>* = NULL);
        
        void Ordina(bool = true, int = 0, int =-1);
        template<typename T>
        friend void QuickSort(int, int);
        
        Tipo LeggiElemento(int);
        void ScriviElemento(int, Tipo);
                        
        void StampaElementi();
        
        Lista<Tipo> FusioneLista(Lista<Tipo>);
        
        void Next();
        void Prev();
        void Rewind();
};

Questa è lo sviluppo del costruttore

template<typename Tipo>
Lista<Tipo>::Lista(const Lista<Tipo>& lista) 
{
    int i = 0;
    
    this->InizioLista = new Nodo<Tipo>(NULL,NULL,NULL);
    this->Current = this->InizioLista;
    
    while(!lista.FineLista())
        this->InserisciInCoda(lista.LeggiElemento(i++));
}

L'errore riportato invece (e che cercando come un forsennato in rete riportando anche la dicitura completa non sono riuscito a risolvere) è il seguente:

passing 'const Lista<int>' as 'this' argument of 'Tipo Lista<Tipo>::LeggiElemento(int) [with Tipo = int] discards qualifiers [-fpermissive]

Questo errore me lo da anche per la funzione FineLista....


Grazie dell'aiuto!

[MItaly]

lista è un const reference, per cui (1) non ne puoi modificare i campi e (2) puoi solo richiamarne i metodi marcati come const (ovvero, che promettono di non modificarne i campi). Leggi:
http://www.parashift.com/c++-faq/const-correctness.html

[mx92]

lista è un const reference, per cui (1) non ne puoi modificare i campi e (2) puoi solo richiamarne i metodi marcati come const (ovvero, che promettono di non modificarne i campi). Leggi:
http://www.parashift.com/c++-faq/const-correctness.html

Perfetto ho capito come funziona...però nel mio caso c'è un problema...Non posso rendere const le funzioni Next e Rewind in quanto queste modificano il puntatore Current...tuttavia non rendendo queste funzioni const non posso andare a compilare.

Codice completo di Lista.cpp

#include "Lista.h"#include <iostream>
#include <string>


using namespace std;


template<typename Tipo>
Lista<Tipo>::Lista()
{
    InizioLista = new Nodo<Tipo>(NULL,NULL,NULL);
    Current = InizioLista;
    DimLista = 0;
}


template<typename Tipo>
Lista<Tipo>::Lista(const Lista<Tipo>& lista) 
{
    int i = 0;
    
    this->InizioLista = new Nodo<Tipo>(NULL,NULL,NULL);
    this->Current = this->InizioLista;
    
    while(!lista.FineLista())
        this->InserisciInCoda(lista.LeggiElemento(i++));
}


template<typename Tipo>bool Lista<Tipo>::ListaVuota() const
{
    if(InizioLista == NULL)
        return true;
    else
        return false;
}


template<typename Tipo>
bool Lista<Tipo>::FineLista() const
{
    if(Current->LeggiProssimoIndirizzo() == NULL)
        return true;
    else
        return false;
}


template<typename Tipo>
int Lista<Tipo>::DimensioneLista() const
{
    return DimLista;
}


template<typename Tipo>
int Lista<Tipo>::PosizioneCursore(Lista<Tipo>* lista)
{
    int indCursore = -1;
    Nodo<Tipo>* Cursore = this->InizioLista;
    
    while(Cursore != Current)
    {
        indCursore++;
        Cursore = Cursore->LeggiProssimoIndirizzo();
    }
    
    return indCursore;
}


template<typename Tipo>
void Lista<Tipo>::InserisciInCoda(Tipo Elemento, Lista<Tipo>* lista)
{    
    static bool flag = false;
    
    if(lista == NULL && !flag)
    {
        flag = true;
        InserisciInCoda(Elemento,this);
        flag = false;
        Rewind();
        return;
    }
    else
    {
        if(FineLista())
        {
            Nodo<Tipo>* NuovoElemento;
            
            NuovoElemento = new Nodo<Tipo>(Elemento,lista->Current);
            lista->Current->ScriviProssimoIndirizzo(NuovoElemento);
            lista->DimLista++;
            return;
        }
        else
        {
            Next();
            InserisciInCoda(Elemento,lista);
        }
        
    }
}


template<typename Tipo>
void Lista<Tipo>::InserisciInPosizione(Tipo Elemento, int Indice, Lista<Tipo>* lista)
{
    static bool flag = false;
    Nodo<Tipo>* NuovoElemento;
    
    if(lista == NULL && !flag)
    {
        if(Indice > DimensioneLista() - 1)
        {
            cout << "Indice oltre il limite...sara' effettuato un inserimento in coda..." << endl;
            InserisciInCoda(Elemento,lista);
            return;
        }
        
        flag = true;
        InserisciInPosizione(Elemento, Indice, this);
        flag = false;
        Rewind();
        return;
    } 
    else
    {
        if(PosizioneCursore() == Indice)
        {
            NuovoElemento = new Nodo<Tipo>(Elemento);
            
            Current->LeggiPrecedenteIndirizzo()->ScriviProssimoIndirizzo(NuovoElemento);
            NuovoElemento->ScriviPrecedenteIndirizzo(Current->LeggiPrecedenteIndirizzo());
            NuovoElemento->ScriviProssimoIndirizzo(Current);
            lista->DimLista++;
            return;
        }
        else
        {
            Next();
            InserisciInPosizione(Elemento, Indice, lista);
        }
    }
}


template<typename Tipo>
void Lista<Tipo>::Next() const
{
    if(!ListaVuota() && !FineLista())
        Current = Current->LeggiProssimoIndirizzo();    
}


template<typename Tipo>
void Lista<Tipo>::Rewind() const
{
    Current = InizioLista;
}


template<typename Tipo>
void Lista<Tipo>::StampaElementi()
{
    Rewind();
    
    Next();
    while(!FineLista())
    {
        cout << Current->LeggiElemento() << endl;    
        Next();
    }
    
    cout << Current->LeggiElemento();
}


template<typename Tipo>
void Lista<Tipo>::Ordina(bool Direzione, int Begin, int End)
{
    int q;
    int Dim = DimensioneLista() - 1;
    
    if(End == -1)
        End = Dim;
    
    if(End > Dim)
        cout << "Parametri di ordinamento errati!!!" << endl;
    else
        QuickSort(this,Begin,End);
}


template<typename Tipo>
Tipo Lista<Tipo>::LeggiElemento(int Indice) const
{
    int i;
    Tipo Elemento;
    
    if(Indice > DimensioneLista())
        cout << "Indice errato!!" << endl;
    else
    {
        for(i = -1; i < Indice; i++)
            Next();
            
        Elemento = Current->LeggiElemento();
        Rewind();
        
        return Elemento;
    }
}


template<typename Tipo>
void Lista<Tipo>::ScriviElemento(int Indice, Tipo Elemento)
{
    int i;
    
    if(Indice > DimensioneLista() - 1)
        cout << "Indice errato!!" << endl;
    else
    {
        for(i = -1; i < Indice; i++)
            Next();
            
        Current->ScriviElemento(Elemento);
        Rewind();
    }
}


template<typename Tipo>
int Partizione(Lista<Tipo>* lista, int Begin, int End)
{
    Tipo Aux;
    int i = Begin - 1;
    int j = End + 1;
    
    Tipo x = lista->LeggiElemento(Begin);
    
    while(i < j)
    {
        while(lista->LeggiElemento(--j) > x);
        while(lista->LeggiElemento(++i) < x);
        
        if(i < j)
        {
            Aux = lista->LeggiElemento(i);
            lista->ScriviElemento(i,lista->LeggiElemento(j));
            lista->ScriviElemento(j,Aux);
        }
    }
    
    return j;
}


template<typename Tipo>
void QuickSort(Lista<Tipo>* lista, int Begin, int End)
{
    int q;
    
    if(Begin < End)
    {
        q = Partizione(lista,Begin,End);
        
        QuickSort(lista,Begin,q);
        QuickSort(lista,q+1,End);
    }
}


template<typename Tipo>
Lista<Tipo> Lista<Tipo>::FusioneLista(Lista<Tipo> Lista2)
{
    Lista<Tipo> ListaFusa;
    int i = 0, j = 0, k = 0;
    
    while(!this->FineLista() && !Lista2.FineLista())
    {
        if(this->LeggiElemento(i) < Lista2.LeggiElemento(j))
            ListaFusa.InserisciInCoda(this->LeggiElemento(i++));
        else
            ListaFusa.InserisciInCoda(Lista2.LeggiElemento(j++));    
    }
    
    while(!this->FineLista())
        ListaFusa.InserisciInCoda(this->LeggiElemento(i++));
    while(!Lista2.FineLista())
        ListaFusa.InserisciInCoda(Lista2.LeggiElemento(j++));
        
    return ListaFusa;
}


template class Lista<int>;
template class Lista<string>;

[MItaly]

Il problema nel tuo caso è che la tua classe lista fa sia da contenitore dati che da cursore, e normalmente queste due cose si tengono separate. L'idioma classico è quello degli iteratori: chiamando un certo metodo del contenitore dati ti viene restituito un oggetto che ti consente di scorrere i dati del contenitore associato (l'iteratore, appunto), per cui in questa maniera è possibile leggere i dati senza alterare l'oggetto-contenitore.