Salve a tutti, non riesco a fare un esercizio assegnatomi.
L'esercizio riguarda l'implementazione di una classe sequenza con una lista a puntatori.
La classe deve avere le seguenti caratteristiche:
Le variabili private sono: un cursore, che mantiene l'elemento attuale, un precursore, che mantiene l'elemento prima di quello attuale, una testa ed una coda.
La classe lista e le implementazioni delle sue funzioni le ho prese dal libro che mi ha proposto l'esercizio.
Ecco i seguenti files.
Faccio notare che non ho usato nè ereditarietà nè polimorfismo, poichè il prof non li ha trattati ancora.
Il mio problema è che quando provo a stampare la lista, stampa solo il primo elemento e non riesco a capire proprio perchè.
L'errore si trova quasi sicuramente nella funzione "inserisci dopo", (dopo si intende 'dopo il cursore').
Ho provato in molti altri modi ma niente da fare e ci sto sbattendo la testa da due giorni .
Header file della lista:
class nodo{
public:
typedef int value_type;
typedef std::size_t size_type;
//COSTRUTTORI E DISTRUTTORE
nodo(const value_type& dato_iniziale, nodo* link_iniziale){ dato=dato_iniziale; next=link_iniziale;};
//FUNZIONI MEMBRO NON COSTANTI
void set_dato(const value_type nuovo_dato){dato=nuovo_dato;};
void set_link(nodo* nuovo_link){next=nuovo_link;};
//FUNZIONI MEMBRO COSTANTI
value_type valore() const {return dato;};
nodo* link() const {return next;};
bool empty() const {return next==0;};
private:
value_type dato;
nodo* next;
};
std::size_t lunghezza(const nodo* testa);
void inserisci_in_testa(nodo* &testa, const nodo::value_type& dato );
void inserisci(nodo* ptr_precedente, const nodo::value_type& dato);
void rimuovi_in_testa(nodo* &testa);
void rimuovi(nodo* &ptr_precedente);
File cpp della lista:
#include <iostream>
#include <cstdlib>
#include <cassert>
#include "nodoPersonalizzato.h"
using namespace std;
std::size_t lunghezza(const nodo* testa){
const nodo* cursore;
size_t dimensione=0;
for(cursore=testa; cursore!=NULL; cursore=cursore->link()){
dimensione++;
}
return dimensione;
}
void inserisci_in_testa( nodo* &testa, const nodo::value_type& dato){
testa=new nodo(dato, testa);
}
void inserisci( nodo* ptr_precedente, const nodo::value_type& dato){
nodo* ptr_inserito;
ptr_inserito=new nodo(dato, ptr_precedente->link());
ptr_precedente->set_link(ptr_inserito);
}
void rimuovi_in_testa(nodo* &testa){
nodo* ptr_rimuovi;
ptr_rimuovi=testa;
testa=testa->link();
delete ptr_rimuovi;
}
void rimuovi(nodo* ptr_precedente){
nodo* ptr_rimuovi;
ptr_rimuovi=ptr_precedente->link();
ptr_precedente->set_link(ptr_rimuovi->link());
delete ptr_rimuovi;
}
File header della sequenza:
class sequenza{
public:
// DICHIARAZIONE TYPEDEF
typedef int value_type;
typedef std::size_t size_type;
//COSTRUTTORI E DISTRUTTORE
sequenza(){num_nodi=0; testa=NULL; coda=testa; cursore=testa; precursore=testa;};
//VARIABILI MEMBRO NON CONSTANTI
void inizia(){cursore=testa;};
void avanza(){cursore=cursore->link();};
void inserisci_prima(const value_type &input);
void inserisci_dopo(const value_type &input);
void rimuovi_corrente();
void stampa_sequenza();
//VARIABILI MEMBRO COSTANTI
size_t dimensione() const {return (num_nodi);};
nodo* valore_corrente() const {return cursore;};
private:
size_type num_nodi;
nodo* testa;
nodo* coda;
nodo* cursore;
nodo* precursore;
};
File cpp della sequenza:
void sequenza::inserisci_dopo(const value_type &input){
if(testa==NULL){
inserisci_in_testa(testa, input);
cursore=testa;
precursore=testa;
num_nodi++;
//cout<<"questo è il cursore: "<<cursore->valore()<<endl;
}
else{
precursore=cursore;
cursore=new nodo(input,cursore);
num_nodi++;
}
}
void sequenza::rimuovi_corrente(){
}
void sequenza::stampa_sequenza(){
for(inizia(); cursore!=coda; avanza()){
cout<<cursore->valore();
cout<<endl;
}
}