Pagina 1 di 3 1 2 3 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 25
  1. #1
    Utente di HTML.it
    Registrato dal
    Jan 2010
    Messaggi
    211

    C++ classe virtuale

    ciao a tutti, ho creato la struttura dati lista come classe base con dei metodi virtuali, dopo di che ho implementato i metodi virtuali nella classe derivata. nel test della classe mi da un errore che non riesco a comprendere a cosa sia dovuto. ecco i codici:

    lista.h
    codice:
    #ifndef lista_h
    #define lista_h
    
    #include <iostream>
    #include <stdlib.h>
    
    using namespace std;
    
    template<class posizione, class tipoelem>
    class lista
    {
       public:
          virtual void crealista() = 0;
          virtual bool listavuota() = 0;
          virtual posizione primolista() = 0;
          virtual bool finelista(posizione) = 0;
          virtual posizione succlista(posizione) = 0;
          virtual posizione predlista(posizione) = 0;
          virtual tipoelem leggilista(posizione) = 0;
          virtual void scrivilista(poszione, tipoelem) = 0;
          virtual void inslista(posizione, tipoelem) = 0;
          virtual void canclista(posizione) = 0;
          
          void fondiordinate(lista &, lista &);
          void epurazione();
          void naturalmergesort();
       private:
          void distribuisci(lista &, lista &);
          void copiacatena(posizione &, lista, posizione &, lista &);
          void copia(posizione &, lista, posizione &, lista &, bool &);
          void merge(lista, lista, lista &, int &);
          void findicatena(posizione &, lista, posizione &, lista, posizione &, lista &);
          
    };
    
    #endif
    
    template<class posizione, class tipoelem>
    void lista<posizione, tipoelem>::fondiordinate(lista<posizione, tipoelem> &a, lista<posizione, tipoelem> &b)
    {
       posizione pa = a.primolista();
       posizione pb = b.primolista();
       posizione pc = primolista();
       
       while(!a.finelista(pa) && !b.finelista(pb))
       {
          if(a.leggilista(pa) <= b.leggilista(pb))
          {
             inslista(pc, a.leggilista(pa));
             pa = a.succlista(pa);
          }
          else
          {
             inslista(pc, b.leggilista(pb));
             pb = b.succlista(pb);
          }
          pc = succlista(pc);
       }
       
       while(!a.finelista(pa))
       {
          inslista(pc, a.leggilista(pa));
          pa = a.succlista(pa);
          pc = succlista(pc);
       }
       while(!b.finelista(pb))
       {
          inslista(pc, b.leggilista(pb));
          pb = b.succlista(pb);
          pc = succlista(pc);
       }
    }
    
    template<class posizione, class tipoelem>
    void lista<posizione, tipoelem>::epurazione()
    {
       posizione p = primolista();
       posizione q;
       posizione t;
       while(!finelista(p))
       {
          q = succlista(p);
          while(!finelista(q))
          {
             if(leggilista(p) == leggilista(q))
             {
                t = succlista(q);
                canclista(q);
                q = t;
             }
             else
                q = succlista(q);
          }
          p = succlista(p);
       }
    }
    
    template<class posizione, class tipoelem>
    void lista<posizione, tipoelem>::naturalmergesort()
    {
       int numerocatene;
       lista<posizione, tipoelem> A, B, L;
       do
       {
          A.crealista();
          B.crealista();
          distribuisci(&A, &B);
          numerocatene = 0;
          crealista();
          merge(A, B, &L, &numerocatene);
       }while(numerocatene != 1)
    }
    
    template<class posizione, tipoelem>
    void lista<posizione, tipoelem>::distribuisci(lista<posizione, tipoelem> &A, lista<posizione, tipoelem> &B)
    {
       posizione p = primolista();
       posizione pa = A.primolista();
       posizione pb = B.primolista();
       do
       {
          copiacatena(&p, this, &pa, &A);
          if(!finelista(p))
             copiacatena(&p, this, &pb, &B);
       }while(!finelista(p)
    }
    
    template<class posizione, class tipoelem>
    void lista<posizione, tipoelem>::copiacatena(posizione &p, lista<posizione, tipoelem> L, posizione &pa, lista<posizione, tipoelem> &A)
    {
       bool finecatena = false;
       do
          copia(&p, this, &pa, &A, &finecatena);
       while(!finecatena)
    }
    
    template<class posizione, class tipoelem>
    void lista<posizione, tipoelem>::copia(posizione &p, lista<posizione, tipoellem> L, posizione &pa, lista<posizione, tipoelem> &a, bool &finecatena)
    {
       tipoelem elemento = leggilista(p);
       A.inslista(pa, elemento);
       p = succlista(p);
       pa = succlista(pa);
       if(finelista(p)
          finecatena = true;
       else
          finecatena = (elemento > leggilista(p));
    }
    
    template<class posizione, class tipoelem>
    void lista<posizione, tipoelem>::merge(lista<posizione, tipoelem> A, lista<posizione, tipoelem> B, lista<posizione, tipoelem> &L, int &numcatene)
    {
       posizione p = primolista();
       posizione pa = A.primolista();
       posizione pb = B.primolista();
       
       while(!A.finelista(pa) && !B.finelista(pb))
       {
          fondicatena(&pa, A, &pb, B, &p, &L)
          numcatene++;
       }
       while(!A.finelista(pa))
       {
          copiacatena(&pa, A, &p, &L);
          numcatene++;
       }
       while(!B.finelista(pb))
       {
          copiacatena(&pb, B, &p, &L);
          numcatene++;
       }
    }
    listap.h
    codice:
    #ifndef _listap_h
    #define _listap_h
    
    #include "nodop.h"
    #include "lista.h"
    #include <iostream>
    #include <stdlib.h>
    #include <stdio.h>
    
    using namespace std;
    
    template<class tipoelem>
    class listap : public lista<tipoelem>
    {
       public:
          typedef nodo<tipoelem> *posizione;    //tipo posizione
               
          listap();                             //costruttore di default
          void crealista();                     //crea la lista vuota
          bool listavuota();                    //stabilisce se la lista è vuota o meno
          posizione primolista();               //restituisce la posizione del primo elemento della lista
          bool finelista(posizione);            //stabilisce se il nodo è l'ultimo della lista
          tipoelem leggilista(posizione);       //restituisce l'elemento della posizione specificata
          posizione succlista(posizione);       //restituisce la posizione del nodo successivo 
          posizione predlista(posizione);       //restituisce la posizione del nodo precedente
          void scrivilista(posizione, tipoelem);//scrive l'elemtno nel nodo specificato dalla posizione
          void inslista(posizione &, tipoelem); //inserisce un nodo e scrive l'elemento nella posizione specificata 
          void canclista(posizione &);          //elimina il nodo nella posizione specificata
       private:
          nodo<tipoelem> cella;                 //nodo della lista (nodo sentinella)
    };
    
    #endif
    
    template<class tipoelem>
    listap<tipoelem>::listap()
    {
       crealista();                             //il costruttore invoca il metodo crealista
    }
    
    template<class tipoelem>
    void listap<tipoelem>::crealista()
    {
       cella.setprec(&cella);
       cella.setsuc(&cella);
       cella.setelem(0);
    }
    
    template<class tipoelem>
    bool listap<tipoelem>::listavuota()
    {
       return((cella.getprec() == &cella) && (cella.getsuc() == &cella));
    }
    
    template<class tipoelem>
    typename listap<tipoelem>::posizione listap<tipoelem>::primolista()
    {
       return(cella.getsuc());
    }
    
    template<class tipoelem>
    bool listap<tipoelem>::finelista(typename listap<tipoelem>::posizione pos)
    {
       return(pos->getsuc() == &cella);
    }
    
    template<class tipoelem>
    tipoelem listap<tipoelem>::leggilista(typename listap<tipoelem>::posizione pos)
    {
       return(pos->getelem());
    }
    
    template<class tipoelem>
    void listap<tipoelem>::scrivilista(typename listap<tipoelem>::posizione pos, tipoelem elem)
    {
       pos->setelem(elem);
    }
    
    template<class tipoelem>
    typename listap<tipoelem>::posizione listap<tipoelem>::succlista(typename listap<tipoelem>::posizione pos)
    {
       return(pos->getsuc());
    }
    
    template<class tipoelem>
    typename listap<tipoelem>::posizione listap<tipoelem>::predlista(typename listap<tipoelem>::posizione pos)
    {
       return(pos->getprec());
    }
    
    template<class tipoelem>
    void listap<tipoelem>::inslista(typename listap<tipoelem>::posizione &pos, tipoelem elem)
    {
       posizione temp = new nodo<tipoelem>;
       
       temp->setprec(pos->getprec());
       temp->setsuc(pos);
       (pos->getprec())->setsuc(temp);
       pos->setprec(temp);
       temp->setelem(elem);
       pos = temp;
    }
    
    template<class tipoelem>
    void listap<tipoelem>::canclista(typename listap<tipoelem>::posizione &pos)
    {
       posizione temp = pos;
       (pos->getsuc())->setprec(pos->getprec());
       (pos->getprec())->setsuc(pos->getsuc());
       pos = pos->getsuc();
       delete temp;
    }
    testlistap.cpp
    codice:
    #include "lista.h"
    #include "listap.h"
    #include <iostream>
    #include <stdlib.h>
    
    using namespace std;
    
    int main()
    {
       listap<int> list;
       listap<int>::posizione pos = list.primolista();
       
       cout << "popolamento della lista con 10 elementi\n";
       for(int i = 1; i < 10; i++)
       {
          list.inslista(pos, i);
          pos = list.succlista(pos);
       }
       system("pause");
       
       cout << "\n\nvisualizzazione degli elementi della lista e del primo elemento della lista\n";
       pos = list.primolista();
       int i = 1;
       while(pos != list.predlista(list.primolista()))
       {
          cout << "elemento " << i++ << "\t";
          cout << pos << "\t";
          cout << list.predlista(pos) << " " << list.leggilista(pos) << " " << list.succlista(pos) << "\n";
          pos = list.succlista(pos);
       }
       cout << "\n\n" << list.primolista() << "\n";
       system("pause");
       
       cout << "\n\neliminazione del primo elemento e visualizzazione della lista\n";
       pos = list.primolista();
       list.canclista(pos);
       while(pos != list.predlista(list.primolista()))
       {
          cout << list.predlista(pos) << " " << list.leggilista(pos) << " " << list.succlista(pos);
          cout << "\tfinelista: " <<list.finelista(pos) << "\n";
          pos = list.succlista(pos);
       }
       cout << list.primolista() << "\n";
       system("pause");
       
       cout << "\n\neliminazione di tutti gli elementi della lista\n";
       pos = list.primolista();
       while(pos != list.predlista(list.primolista()))
       {
          cout << pos << "\n";
          list.canclista(pos);
          system("pause");
       }
          
       list.canclista(pos);
       cout << list.primolista() << "\n\n";
       system("pause");
       
       if(list.listavuota())
          cout << "\n\nla lista e' vuota!!!\n\n";
       
       system("pause");
       return 0;
    }
    l'errore che mi viene dato quando compilo il codice cpp è il seguente:

    20 C:\Dev-Cpp\esercizi\Lista\lista.h `scrivilista' declared as a `virtual' field
    20 C:\Dev-Cpp\esercizi\Lista\lista.h expected `;' before '(' token

    a cosa è dovuto??? vi prego rispondete!!!

  2. #2
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,466
    poszione ?
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  3. #3
    Utente di HTML.it
    Registrato dal
    Jan 2010
    Messaggi
    211
    grazie oregon, ho corretto ma è sorto un altro problema. mi dà il seguente errore:

    40 C:\Dev-Cpp\esercizi\Lista\lista.h redefinition of `void lista<posizione, tipoelem>::fondiordinate(lista<posizione, tipoelem>&, lista<posizione, tipoelem>&)'

    io ho sempre implementato così i metodi di una classe. perchè mi da questo errore???

  4. #4
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,466
    Originariamente inviato da pietrol83
    redefinition
    così ...

    void fondiordinate(lista &, lista & );

    o così ...

    template<class posizione, class tipoelem>
    void lista<posizione, tipoelem>::fondiordinate(lista<posizione, tipoelem> &a, lista<posizione, tipoelem> &b)

    ?
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  5. #5
    Utente di HTML.it
    Registrato dal
    Jan 2010
    Messaggi
    211
    oregon non ti seguo...

  6. #6
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,466
    template<class posizione, class tipoelem>
    void lista<posizione, tipoelem>::fondiordinate(lista<posizione, tipoelem> &a, lista<posizione, tipoelem> &b)
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  7. #7
    Utente di HTML.it
    Registrato dal
    Jan 2010
    Messaggi
    211
    dov'è secondo te il problema??? io penso di aver scritto bene il template e la segnatura del metodo

  8. #8
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,466
    Manca un ; in

    }while(numerocatene != 1)

    e un ); in

    }while(!finelista(p)

    e poi ci sono altri errori (nomi scritti con piccoli errori ...) che seguono ma che dovresti vedere facilmente dal messaggio d'errore ...
    No MP tecnici (non rispondo nemmeno!), usa il forum.

  9. #9
    Utente di HTML.it
    Registrato dal
    Jan 2010
    Messaggi
    211
    il ";" e ");" sono inseriti correttamente ma mi dà problemi al metodo fondiordinate. il messaggio di errore è quello che ho scritto su ma non riesco a capire cosa è sbagliato. per quanto riguarda gli altri errori so che ci sono ma quelli li correggo man mano che vado avanti.

  10. #10
    Utente di HTML.it L'avatar di oregon
    Registrato dal
    Jul 2005
    residenza
    Roma
    Messaggi
    36,466
    Beh ... se controlli nel listato che hai postato quegli ; non esistono !

    E non c'è neanche nodop.h ...
    No MP tecnici (non rispondo nemmeno!), usa il forum.

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.