C++, overloading del'operatore ==

[pietrol83]

ciao, ho sovraccaricato l'operatore == nella calsse lista e ho scritto un codice per controllare se l'operatore è stato sovraccaricato correttamente ma, a quanto pare no. posto i codici della classe e la prova del sovraccaricAmento:

listap.h

#ifndef _LISTAP_H
#define _LISTAP_H

#include <iostream>

using namespace std;

template<class T> class lista
{
    private:
        typedef T tipoelem;
        struct nodo
        {
            nodo *precedente;
            tipoelem elemento;
            nodo *successivo;
        };
    public:
        typedef nodo * posizione;
        posizione sentinella;
            
        lista();
        void crealista();
        bool listavuota();
        posizione primolista();
        bool finelista(posizione);
        void inslista(posizione&, tipoelem&);
        void canclista(posizione&);
        tipoelem leggilista(posizione);
        void scrivilista(posizione&, tipoelem&);
        posizione predlista(posizione);
        posizione succlista(posizione);
        
        bool operator==(lista<T> const &);
};
#endif

template<class T> lista<T>::lista()
{
	crealista();
}

template<class T> void lista<T>::crealista()
{
	sentinella = (posizione)malloc(sizeof(nodo));
    tipoelem elemnullo = 0;
	sentinella->precedente = sentinella;
	sentinella->elemento = elemnullo;
	sentinella->successivo = sentinella;
}

template<class T> bool lista<T>::listavuota()
{
	return((sentinella->precedente == sentinella) && (sentinella->successivo == sentinella));
}

template<class T> typename lista<T>::posizione lista<T>::primolista()
{
    return(sentinella->successivo);
}

template<class T> bool lista<T>::finelista(posizione p)
{
    return(p->successivo == sentinella);
}

template<class T> void lista<T>::inslista(lista<T>::posizione &p, tipoelem& elem)
{
    posizione temp = new nodo;
    temp->elemento = elem;
    temp->precedente = p->precedente;
    temp->successivo = p;
    p->precedente->successivo = temp;
    p->precedente = temp;
    p = temp;
}

template<class T> void lista<T>::canclista(posizione &p)
{
    posizione temp = p;
    p->precedente->successivo = p->successivo;
    p->successivo->precedente = p->precedente;
    p = p->successivo;
    delete(temp);
}

template<class T> typename lista<T>::tipoelem lista<T>::leggilista(posizione p)
{
    return(p->elemento);
}

template<class T> void lista<T>::scrivilista(posizione &p, tipoelem& elem)
{
    p->elemento = elem;
}

template<class T> typename lista<T>::posizione lista<T>::predlista(posizione p)
{
    return(p->precedente);
}

template<class T> typename lista<T>::posizione lista<T>::succlista(posizione p)
{
    return(p->successivo);
}

template<class T> bool lista<T>::operator==(lista<T> const &lis)
{
    typename lista<T>::posizione p1 = this->primolista();
    typename lista<T>::posizione p2 = lis.primolista();
    bool esito = false;
    bool fine = false;
    
    while(((p1 != this.sentinella) && (p1 != lis.sentinella)) && fine == false)
    {
        if(this.leggilista(p1) == lis.leggilista(p2))
            esito = true;
        else
        {
            esito = false;
            fine = true;
        }
        p1 = this.succlista(p1);
        p2 = lis.succlista(p2);
    }
    return esito;
}

esercizio5.cpp

#include <cstdlib>
#include <iostream>
#include "listap.h"

using namespace std;

int main(int argc, char *argv[])
{
    lista<int> lista1, lista2;
    
    lista<int>::posizione p1 = lista1.primolista();
    lista<int>::posizione p2 = lista2.primolista();
    
    for(int a = 0; a < 10; a++)
    {
        lista1.inslista(p1, a);
        p1 = lista1.succlista(p1);
    }
    for(int a = 0; a < 10; a++)
    {
        lista2.inslista(p2, a);
        p2 = lista2.succlista(p2);
    }
    
    if(lista1 == lista2)
        cout << 1;
    else
        cout << 0;
        
    cout << "\n\n";
    
    system("PAUSE");
    return EXIT_SUCCESS;
}

mi viene visualizzato il seguente errore:

110 C:\Dev-Cpp\esercizi\liste\listap.h passing `const lista<int>' as `this' argument of `typename lista<T>:osizione lista<T>:rimolista() [with T = int]' discards qualifiers.

ma dov'è l'errore???

[antotan]

puoi indicare la posizione del metodo che ti provoca l'errore?

Solitamente è un errore che ottieni quando richiamo un metodo non const su un oggetto const:

class T 
{ 
    public: 
        void f() {} 
};

int main() 
{
    const T t = T();
    t.f();
} 

Questo codice ti da lo stesso errore postato da te. Lo risolvi dichiarando il metodo const (che tra l'altro è buona norma, quando il metodo non deve modificare lo stato dell'oggetto):

class T 
{ 
    public: 
        void f() const {}  // nota const
};

int main() 
{
    const T t = T();
    t.f();
} 

[pietrol83]

allora la compilazione si blocca quando il compilatore arriva all'istruzione if(lista1 == lista2)...
del codice esercizio5.cpp e mi segnala l'errore nella classe lista all'altezza del codice relativo al metodo operator== visualizzandomi l'errore che ho scritto sopra. non riesco a risolverlo

[antotan]

Senza entrare nei dettagli implementativi della tua classe, ogni metodo che richiama lis all'interno di operator==, deve essere const

template<class T> bool lista<T>::operator==(lista<T> const &lis)
{
    typename lista<T>::posizione p1 = this->primolista();
    typename lista<T>::posizione p2 = lis.primolista(); // primolista deve essere const
    bool esito = false;
    bool fine = false;
    
    while(((p1 != this.sentinella) && (p1 != lis.sentinella)) && fine == false)
    {
        if(this.leggilista(p1) == lis.leggilista(p2)) // leggilista deve essere const
            esito = true;
        else
        {
            esito = false;
            fine = true;
        }
        p1 = this.succlista(p1);
        p2 = lis.succlista(p2); // succlista deve essere const
    }
    return esito;
} 

Se alcuni dei metodi che ti ho elencato non possono essere const (ripeto, non entro nei dettagli della tua implementazione, quindi devi valutare un pò tu), allora lis non può essere const.