[C++] overloading dell'operatore <

[pietrol83]

ciao ragazzi, posto un altro problema sulle liste che non riesco a risolvere: ho sovraccaricato l'operatore relazionale < nella classe lista per adattarlo alle stringhe (ho rappresentato le stringhe come puntatori a carattere). secondo me il codice che ho scritto per sovraccaricare l'operatore è corretto però nel codice di prova che ho fatto mi da sempre come risultato il valore booleano vero anche quando il confronto è falso. dove ho sbagliato? vi posto i codici.

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<(const char *);
        bool operator>(char *);
};
#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 <(const char *str)
{
    bool risultato = false;
    bool fine = false;
    int i = 0;
    do
    {
        cout << this.elemento[i] << "\t" << str[i] << "\n\n";
        if(((int)this->elemento[i] < (int)str[i]))
        {
            risultato = true;
            fine = true;
        }
        else
            if((this.elemento[i] != '\0') && (str[i] == '\0'))
                fine = true;
            else
                i++;
    } while(((this.elemento[i] != '\0') && (str[i] != '\0')) && (fine == false));
    return risultato;
}

template<class T> bool lista<T>::operator>(char *str)
{
    bool risultato = false;
    bool flag = false;
    int i = 0;
    char *elementostr = this.elemento;
    while((this.elemento[i] != '\0') || (elementostr[i] != '\0') && (risultato == false))
    {
        if((this.elemento[i] != '\0') && (elementostr[i] == '\0'))
        {
            risultato = true;
            flag = true;
        }
        else
        {
            if((this.elemento[i] == '\0') && (elementostr[i] != '\0'))
                flag = true;
            else
                i++;
        }
    }
    return(risultato);
}

esercizio4

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

using namespace std;

int main(int argc, char *argv[])
{
    lista<char *> lis;
    lista<char *>::posizione p = lis.primolista();
    char *parola1 = "ab";
    char *parola2 = "aa";
    
    lis.inslista(p, parola1);
    p = lis.succlista(p);
    lis.inslista(p, parola2);
    p = lis.primolista();
    
    cout << lis.leggilista(p) << "\t";
    cout << lis.leggilista(lis.succlista(p)) << "\n\n";
    
    p = lis.primolista();
    
    bool esito = (lis.leggilista(p) < lis.leggilista(lis.succlista(p)));
    cout << esito << "\n\n";
    
    p = lis.primolista();
    
    if(lis.leggilista(p) < lis.leggilista(lis.succlista(p)))
        cout << 1;
    else
        cout << 0;
    
    cout << "\n\n";     
    
    system("PAUSE");
    return EXIT_SUCCESS;
}

[pietrol83]

nessuno mi sa dire dove ho sbagliato?

[shodan]

A parte che confronti mele e pere?
Non ha nessun senso logico fare un confronto tra una lista e un const char*. I confronti si fanno tra insiemi o elementi omogenei.
Tra l'altro quell'operatore inficia il senso stesso del template. Se istanzi la lista con un dato utente, si ricade nel caso di prima.
Comunque il tuo problema è che l'operatore in questione non è mai invocato, per quello non ti funziona.

bool esito = (lis.leggilista(p) < lis.leggilista(lis.succlista(p)));

Il confronto avviene sugli elementi restituiti, non tramite l'operatore che hai definito.
Per usare l'operatore devi modificare così:

bool esito = (lis < lis.leggilista(lis.succlista(p)));