[C++] Problema Lettura da File ADT vettore

**Mrhide1** · 30-09-2018, 10:23

MAIN

codice:

#include <iostream>
#include "Vettore.h"
#include "Lettera.h"


using namespace std;
using namespace miospazio;


int main ()
{
	/*
	//			TEST COSTRUTTORI 
	Lettera l;
	Lettera l1 (1,"io",3,"DOC","io","tu");
	Lettera l2=l1;
	
	//cin >> l;
	cout << l;
	
	cout << l1;
	cout << "\n________________________________\n";
	cout << l2;
	cout << "\n_________TEST LETTURA DA FILE_________\n";
	
	Lettera l3;
	ifstream filein;
	filein.open("input.txt");
	
	l3.visualizza_dati(filein);
	cout << l3;
	
	cout << "\n________TEST STAMPA SU FILE___________\n";
	ofstream fileout;
	fileout.open("output.txt");
	l1.memorizza_dati(fileout);
	
	cout << "\n________TEST FUNZIONI DI GESTIONE VETTORE___________\n";
	Vettore v;
	Lettera l1 (1,"io",11,"DOC","io","tu");
	Lettera l2 (5,"tu",22,"PDF","tu","egli");
	Lettera l3 (3,"egli",33,"TASCABILE","egli","noi");
	Lettera l4 (2,"noi",44,"Libro","noi","voi");
	Lettera l5 (4,"voi",55,"FUMETTO","voi","loro");


	v.inserimento(&l1);
	v.inserimento(&l2);
	v.inserimento(&l3);
	v.inserimento(&l4);
	v.inserimento(&l5);
		
	v.eliminazione(2);
	
	v.stampafile();
	v.stampavideo();
	*/
	
	Vettore v;
	v.leggifile();
	v.stampavideo();
}

Classe Base Manoscritto

codice:

Manoscritto.h
#ifndef MANOSCRITTO_H
#define MANOSCRITTO_H


#include <iostream>
#include <cstring>
#include <fstream>


using namespace std;


namespace miospazio
{
	class Manoscritto
	{
		friend ostream& operator<<(ostream& out,const Manoscritto& M) 	{return M.stampa(out);}
		friend istream& operator>>(istream& in, Manoscritto& M) 		{return M.leggi(in);}
	
		protected:
			int codice;
			char* autore;
			int numpag;
			char* formato;
			virtual ostream& stampa(ostream&) const;
			virtual istream& leggi(istream&);
		
		public:
			Manoscritto();
			Manoscritto(const int,const char*,const int,const char*);
			Manoscritto(const Manoscritto&);
			virtual ~Manoscritto () {delete [] autore; delete [] formato;}
			
			const Manoscritto& operator= (const Manoscritto&);
			
			const int get_codice () const {return codice;}
			const char* get_autore () const {return autore;}
			const int get_numpag () const {return numpag;}
			const char* get_formato () const {return formato;}
			
			void set_codice 	(const int C) {codice = C;}
			void set_autore 	(const char*);
			void set_numpag		(const int N) {numpag = N;}
			void set_formato 	(const char*);
			
			virtual void memorizza_dati (ofstream&) const {cout << *this;};
			virtual void visualizza_dati (ifstream&);
	};
}
#endif 

Manoscritto.cpp
#include "Manoscritto.h"




namespace miospazio
{
	ostream& Manoscritto::stampa (ostream& out) const
	{
		out << "\nIl codice del manoscritto e': " << codice;
		out << "\nL'autore del manoscritto e': " << autore;
		out << "\nIl numero di pagine del manoscritto e': " << numpag;
		out << "\nIl formato del manoscritto e': " << formato;
		return out;
	}
	
	istream& Manoscritto::leggi (istream& in)
	{
		string buffer;
		int buffernum;
		
		cout << "\nInserire il codice del manoscritto: ";
		in >> buffernum;
		codice=buffernum;
		
		cout << "\nInserire l'autore del manoscritto: ";
		in >> buffer;
		set_autore (buffer.c_str());
		in.ignore();
		
		cout << "\nInserire il numero di pagine del manoscritto: ";
		in >> buffernum;
		numpag = buffernum;
		
		cout << "\nInserire il formato del manoscritto: ";
		in >> buffer;
		set_formato (buffer.c_str());
		
		return in;
	}


	Manoscritto::Manoscritto()
	{
		codice = 0;
		autore = new char [1];
		strcpy(autore,"");
		numpag = 0;
		formato = new char [1];
		strcpy(formato,"");
	}
	
	Manoscritto::Manoscritto(const int C,const char* A,const int N,const char* F)
	{
		codice = C;
		autore = new char [strlen(A)+1];
		strcpy(autore,A);
		numpag = N;
		formato = new char [strlen(F)+1];
		strcpy(formato,F);
	}
	
	Manoscritto::Manoscritto(const Manoscritto& M)
	{
		codice = M.codice;
		autore = new char [strlen(M.autore)+1];
		strcpy(autore,M.autore);
		numpag = M.numpag;
		formato = new char [strlen(M.formato)+1];
		strcpy(formato,M.formato);
	}
	
	const Manoscritto& Manoscritto::operator= (const Manoscritto& M)
	{
		if (this != &M)
		{
			set_codice(M.codice);
			set_autore(M.autore);
			set_numpag(M.numpag);
			set_formato(M.formato);
		}
		return *this;
	}
		
	void Manoscritto::set_autore 	(const char* A)
	{
		delete [] autore;
		autore = new char [strlen(A)+1];
		strcpy(autore,A);
	}
	
	void Manoscritto::set_formato 	(const char* F)
	{
		delete [] formato;
		formato = new char [strlen(F)+1];
		strcpy(formato,F);
	}
	
	void Manoscritto::visualizza_dati (ifstream& file)
	{
		int buffernum;
		string buffertext;
		
			file >> buffernum;
			set_codice(buffernum);
			
			file >> buffertext;
			set_autore(buffertext.c_str());
			
			file >> buffernum;
			set_numpag(buffernum);
			
			file >> buffertext;
			set_formato(buffertext.c_str());
		
	}
}

Classe derivata Lettera

codice:

Lettera.h
#ifndef LETTERA_H
#define LETTERA_H


#include "Manoscritto.h"


using namespace std;


namespace miospazio
{
	class Lettera : public Manoscritto
	{
		friend ostream& operator<<(ostream& out,const Lettera& L) 	{return L.stampa(out);}
		friend istream& operator>>(istream& in, Lettera& L) 		{return L.leggi(in);}
	
		private:
		char* mittente;
		char* destinatario;
		ostream& stampa(ostream&) const;
		istream& leggi(istream&);
		
		public:
		Lettera();
		Lettera(const int,const char*,const int,const char*,const char*,const char*);
		Lettera(const Lettera&);
		~Lettera () {delete [] mittente; delete [] destinatario;}
		
		const Lettera& operator= (const Lettera&);
		
		const char* get_mittente () const {return mittente;}
		const char* get_destinatario () const {return destinatario;}
		
		void set_mittente		(const char*);
		void set_destinatario 	(const char*);
		
		void memorizza_dati (ofstream& file) const {file<<*this;}
		void visualizza_dati (ifstream&);
	};
}
#endif



Lettera.cpp
#include "Lettera.h"


namespace miospazio
{
	ostream& Lettera::stampa(ostream& out) const
	{
		Manoscritto::stampa(out);
		out << "\nIl mittente del manoscritto e': " << mittente;
		out << "\nIl destinatario del manoscritto e': " << destinatario;
		return out;
	}
	
	istream& Lettera::leggi(istream& in)
	{
		Manoscritto::leggi(in);
		string buffer;
		cout << "\nInserire il mittente del manoscritto: ";
		in >> buffer;
		set_mittente(buffer.c_str());
		in.ignore();
		cout << "\nInserire il destinatario del manoscritto: ";
		in >> buffer;
		set_destinatario(buffer.c_str());
		return in;
	}
	
	Lettera::Lettera() : Manoscritto ()
	{
		mittente = new char [1];
		strcpy(mittente,"");
		destinatario = new char [1];
		strcpy(destinatario,"");
	}
	
	Lettera::Lettera(const int C,const char* A,const int N ,const char* F,const char* M,const char* D) : Manoscritto (C,A,N,F)
	{
		mittente = new char [strlen(M)+1];
		strcpy(mittente,M);
		destinatario = new char [strlen(D)+1];
		strcpy(destinatario,D);
	}
	
	Lettera::Lettera(const Lettera& L) : Manoscritto (L)
	{
		mittente = new char [strlen(L.mittente)+1];
		strcpy(mittente,L.mittente);
		destinatario = new char [strlen(L.destinatario)+1];
		strcpy(destinatario,L.destinatario);
	}
		
	const Lettera& Lettera::operator= (const Lettera& L)
	{
		if (this != &L)
		{
			Manoscritto::operator=(L);
			set_mittente (L.mittente);
			set_destinatario (L.destinatario);
		}
		return *this;
	}
		
	void Lettera::set_mittente		(const char* M)
	{
		delete [] mittente;
		mittente = new char [strlen(M)+1];
		strcpy(mittente,M);
	}
	
	void Lettera::set_destinatario 	(const char* D)
	{
		delete [] destinatario;
		destinatario = new char [strlen(D)+1];
		strcpy(destinatario,D);
	}
	
	void Lettera::visualizza_dati (ifstream& file) 
	{
		int buffernum;
		string buffertext;
		
			file >> buffernum;
			set_codice(buffernum);
		
			file >> buffertext;
			set_autore(buffertext.c_str());
			
			file >> buffernum;
			set_numpag(buffernum);
			
			file >> buffertext;
			set_formato(buffertext.c_str());
			
			file >> buffertext;
			set_mittente(buffertext.c_str());
			
			file >> buffertext;
			set_destinatario(buffertext.c_str());		
	 }
}

Contenitore Vettore

codice:

Vettore.h
#ifndef VETTORE_H
#define VETTORE_H


#include "Manoscritto.h"


using namespace std;


namespace miospazio
{
	typedef Manoscritto* T;
	
	class Vettore
	{
		friend ostream& operator<<(ostream&,const Vettore&);
		friend istream& operator>>(istream&, Vettore&);
		private:
			static const int MAX = 10;
			T vet[MAX];
			int riempimento;
			
		public:
			Vettore () {riempimento = 0;}
			Vettore (const int dim) {riempimento = dim;}
						
			bool empty () const {return riempimento==0;}
			bool full  () const {return riempimento==MAX;}
			
			void bubblesort ();
			bool ricerca (const T&);
			bool push (const T&);
			void inserimento (const T&);		
			void eliminazione (const int);
			void stampavideo();
			
			void stampafile() const;
			void leggifile(Vettore&);
	};	
}
#endif

Vettore.cpp
#include "Vettore.h"


namespace miospazio
{
	void Vettore::bubblesort ()
	{
		
		for (int i=1; i<riempimento; i++)
		{
			for (int j=0; j<riempimento-i; j++)
			{
				if (vet[j]->get_codice() > vet[j+1]->get_codice())
				{
					T temp;
					temp = vet[j];
					vet[j] = vet[j+1];
					vet[j+1] = temp;
				}
			}
		}
	}
	
	bool Vettore::ricerca (const T& a) 
	{
		bool trovato = false;
		int i = 0;
		while (i<riempimento && trovato == false)
		{
			if (a->get_codice()==vet[i]->get_codice())
			{
				trovato = true;
			}
			else i++;
		}
		return trovato;	
	}
	
	bool Vettore::push (const T& a)
	{
		if (full()) return false;
		else 
		{
			vet[riempimento] = a;
			riempimento++;
			return true;
		}
	}
	
	void Vettore::inserimento (const T& a)
	{
		if (ricerca(a)==false)
		{
			push (a);
			bubblesort();	
		}
		else cout << "Errore codice già presente nell'elenco";
		
	}


	void Vettore::eliminazione (const int C)
	{
		bool trovato = false;
		int i = 0;
		
		while (i<riempimento && trovato == false)
		{
			if (vet[i]->get_codice()==C)
			{
				vet[i] = vet[riempimento-1];
				riempimento--;
				bubblesort();
				trovato = true;
			}
			else i++;
		}
		
		
		if (trovato==true)
		cout << "\nL'elemento di codice " << C << " e' stato eliminato con successo\n";	
	}
	
	void Vettore::stampavideo ()
	{
		for (int i=0; i<riempimento; i++)
		{
			cout << *vet[i];
			cout << "\n";
		}
		
	}
	
	void Vettore::stampafile () const
	{
		ofstream file;
		file.open("output.txt");
	
		for (int i=0; i<riempimento; i++)
		{
			vet[i]->memorizza_dati(file);
			file << "\n___________________________\n";
		}
		
	}	
	
	void Vettore::leggifile()
	{
		ifstream file;
		file.open("input.txt");
		
		if (!file)	cout << "\nErrore aperture file";
		else 
		{
			int i = 0;
			while(!file.eof())
			{
				
			 	vet[i]->visualizza_dati(file);
				i++;
			}
			file.close();	
		}	
	}
}

**Mrhide1** · 30-09-2018, 10:25

MAIN

codice:

#include <iostream>
#include "Vettore.h"
#include "Lettera.h"


using namespace std;
using namespace miospazio;


int main ()
{
	/*
	//			TEST COSTRUTTORI 
	Lettera l;
	Lettera l1 (1,"io",3,"DOC","io","tu");
	Lettera l2=l1;
	
	//cin >> l;
	cout << l;
	
	cout << l1;
	cout << "\n________________________________\n";
	cout << l2;
	cout << "\n_________TEST LETTURA DA FILE_________\n";
	
	Lettera l3;
	ifstream filein;
	filein.open("input.txt");
	
	l3.visualizza_dati(filein);
	cout << l3;
	
	cout << "\n________TEST STAMPA SU FILE___________\n";
	ofstream fileout;
	fileout.open("output.txt");
	l1.memorizza_dati(fileout);
	
	cout << "\n________TEST FUNZIONI DI GESTIONE VETTORE___________\n";
	Vettore v;
	Lettera l1 (1,"io",11,"DOC","io","tu");
	Lettera l2 (5,"tu",22,"PDF","tu","egli");
	Lettera l3 (3,"egli",33,"TASCABILE","egli","noi");
	Lettera l4 (2,"noi",44,"Libro","noi","voi");
	Lettera l5 (4,"voi",55,"FUMETTO","voi","loro");


	v.inserimento(&l1);
	v.inserimento(&l2);
	v.inserimento(&l3);
	v.inserimento(&l4);
	v.inserimento(&l5);
		
	v.eliminazione(2);
	
	v.stampafile();
	v.stampavideo();
	*/
	
	Vettore v;
	v.leggifile();
	v.stampavideo();
}

Classe Base Manoscritto

codice:

Manoscritto.h
#ifndef MANOSCRITTO_H
#define MANOSCRITTO_H


#include <iostream>
#include <cstring>
#include <fstream>


using namespace std;


namespace miospazio
{
	class Manoscritto
	{
		friend ostream& operator<<(ostream& out,const Manoscritto& M) 	{return M.stampa(out);}
		friend istream& operator>>(istream& in, Manoscritto& M) 		{return M.leggi(in);}
	
		protected:
			int codice;
			char* autore;
			int numpag;
			char* formato;
			virtual ostream& stampa(ostream&) const;
			virtual istream& leggi(istream&);
		
		public:
			Manoscritto();
			Manoscritto(const int,const char*,const int,const char*);
			Manoscritto(const Manoscritto&);
			virtual ~Manoscritto () {delete [] autore; delete [] formato;}
			
			const Manoscritto& operator= (const Manoscritto&);
			
			const int get_codice () const {return codice;}
			const char* get_autore () const {return autore;}
			const int get_numpag () const {return numpag;}
			const char* get_formato () const {return formato;}
			
			void set_codice 	(const int C) {codice = C;}
			void set_autore 	(const char*);
			void set_numpag		(const int N) {numpag = N;}
			void set_formato 	(const char*);
			
			virtual void memorizza_dati (ofstream&) const {cout << *this;};
			virtual void visualizza_dati (ifstream&);
	};
}
#endif 

Manoscritto.cpp
#include "Manoscritto.h"




namespace miospazio
{
	ostream& Manoscritto::stampa (ostream& out) const
	{
		out << "\nIl codice del manoscritto e': " << codice;
		out << "\nL'autore del manoscritto e': " << autore;
		out << "\nIl numero di pagine del manoscritto e': " << numpag;
		out << "\nIl formato del manoscritto e': " << formato;
		return out;
	}
	
	istream& Manoscritto::leggi (istream& in)
	{
		string buffer;
		int buffernum;
		
		cout << "\nInserire il codice del manoscritto: ";
		in >> buffernum;
		codice=buffernum;
		
		cout << "\nInserire l'autore del manoscritto: ";
		in >> buffer;
		set_autore (buffer.c_str());
		in.ignore();
		
		cout << "\nInserire il numero di pagine del manoscritto: ";
		in >> buffernum;
		numpag = buffernum;
		
		cout << "\nInserire il formato del manoscritto: ";
		in >> buffer;
		set_formato (buffer.c_str());
		
		return in;
	}


	Manoscritto::Manoscritto()
	{
		codice = 0;
		autore = new char [1];
		strcpy(autore,"");
		numpag = 0;
		formato = new char [1];
		strcpy(formato,"");
	}
	
	Manoscritto::Manoscritto(const int C,const char* A,const int N,const char* F)
	{
		codice = C;
		autore = new char [strlen(A)+1];
		strcpy(autore,A);
		numpag = N;
		formato = new char [strlen(F)+1];
		strcpy(formato,F);
	}
	
	Manoscritto::Manoscritto(const Manoscritto& M)
	{
		codice = M.codice;
		autore = new char [strlen(M.autore)+1];
		strcpy(autore,M.autore);
		numpag = M.numpag;
		formato = new char [strlen(M.formato)+1];
		strcpy(formato,M.formato);
	}
	
	const Manoscritto& Manoscritto::operator= (const Manoscritto& M)
	{
		if (this != &M)
		{
			set_codice(M.codice);
			set_autore(M.autore);
			set_numpag(M.numpag);
			set_formato(M.formato);
		}
		return *this;
	}
		
	void Manoscritto::set_autore 	(const char* A)
	{
		delete [] autore;
		autore = new char [strlen(A)+1];
		strcpy(autore,A);
	}
	
	void Manoscritto::set_formato 	(const char* F)
	{
		delete [] formato;
		formato = new char [strlen(F)+1];
		strcpy(formato,F);
	}
	
	void Manoscritto::visualizza_dati (ifstream& file)
	{
		int buffernum;
		string buffertext;
		
			file >> buffernum;
			set_codice(buffernum);
			
			file >> buffertext;
			set_autore(buffertext.c_str());
			
			file >> buffernum;
			set_numpag(buffernum);
			
			file >> buffertext;
			set_formato(buffertext.c_str());
		
	}
}

**Mrhide1** · 30-09-2018, 10:26

Classe derivata Lettera

codice:

Lettera.h
#ifndef LETTERA_H
#define LETTERA_H


#include "Manoscritto.h"


using namespace std;


namespace miospazio
{
	class Lettera : public Manoscritto
	{
		friend ostream& operator<<(ostream& out,const Lettera& L) 	{return L.stampa(out);}
		friend istream& operator>>(istream& in, Lettera& L) 		{return L.leggi(in);}
	
		private:
		char* mittente;
		char* destinatario;
		ostream& stampa(ostream&) const;
		istream& leggi(istream&);
		
		public:
		Lettera();
		Lettera(const int,const char*,const int,const char*,const char*,const char*);
		Lettera(const Lettera&);
		~Lettera () {delete [] mittente; delete [] destinatario;}
		
		const Lettera& operator= (const Lettera&);
		
		const char* get_mittente () const {return mittente;}
		const char* get_destinatario () const {return destinatario;}
		
		void set_mittente		(const char*);
		void set_destinatario 	(const char*);
		
		void memorizza_dati (ofstream& file) const {file<<*this;}
		void visualizza_dati (ifstream&);
	};
}
#endif



Lettera.cpp
#include "Lettera.h"


namespace miospazio
{
	ostream& Lettera::stampa(ostream& out) const
	{
		Manoscritto::stampa(out);
		out << "\nIl mittente del manoscritto e': " << mittente;
		out << "\nIl destinatario del manoscritto e': " << destinatario;
		return out;
	}
	
	istream& Lettera::leggi(istream& in)
	{
		Manoscritto::leggi(in);
		string buffer;
		cout << "\nInserire il mittente del manoscritto: ";
		in >> buffer;
		set_mittente(buffer.c_str());
		in.ignore();
		cout << "\nInserire il destinatario del manoscritto: ";
		in >> buffer;
		set_destinatario(buffer.c_str());
		return in;
	}
	
	Lettera::Lettera() : Manoscritto ()
	{
		mittente = new char [1];
		strcpy(mittente,"");
		destinatario = new char [1];
		strcpy(destinatario,"");
	}
	
	Lettera::Lettera(const int C,const char* A,const int N ,const char* F,const char* M,const char* D) : Manoscritto (C,A,N,F)
	{
		mittente = new char [strlen(M)+1];
		strcpy(mittente,M);
		destinatario = new char [strlen(D)+1];
		strcpy(destinatario,D);
	}
	
	Lettera::Lettera(const Lettera& L) : Manoscritto (L)
	{
		mittente = new char [strlen(L.mittente)+1];
		strcpy(mittente,L.mittente);
		destinatario = new char [strlen(L.destinatario)+1];
		strcpy(destinatario,L.destinatario);
	}
		
	const Lettera& Lettera::operator= (const Lettera& L)
	{
		if (this != &L)
		{
			Manoscritto::operator=(L);
			set_mittente (L.mittente);
			set_destinatario (L.destinatario);
		}
		return *this;
	}
		
	void Lettera::set_mittente		(const char* M)
	{
		delete [] mittente;
		mittente = new char [strlen(M)+1];
		strcpy(mittente,M);
	}
	
	void Lettera::set_destinatario 	(const char* D)
	{
		delete [] destinatario;
		destinatario = new char [strlen(D)+1];
		strcpy(destinatario,D);
	}
	
	void Lettera::visualizza_dati (ifstream& file) 
	{
		int buffernum;
		string buffertext;
		
			file >> buffernum;
			set_codice(buffernum);
		
			file >> buffertext;
			set_autore(buffertext.c_str());
			
			file >> buffernum;
			set_numpag(buffernum);
			
			file >> buffertext;
			set_formato(buffertext.c_str());
			
			file >> buffertext;
			set_mittente(buffertext.c_str());
			
			file >> buffertext;
			set_destinatario(buffertext.c_str());		
	 }
}

Contenitore Vettore

codice:

Vettore.h
#ifndef VETTORE_H
#define VETTORE_H


#include "Manoscritto.h"


using namespace std;


namespace miospazio
{
	typedef Manoscritto* T;
	
	class Vettore
	{
		friend ostream& operator<<(ostream&,const Vettore&);
		friend istream& operator>>(istream&, Vettore&);
		private:
			static const int MAX = 10;
			T vet[MAX];
			int riempimento;
			
		public:
			Vettore () {riempimento = 0;}
			Vettore (const int dim) {riempimento = dim;}
						
			bool empty () const {return riempimento==0;}
			bool full  () const {return riempimento==MAX;}
			
			void bubblesort ();
			bool ricerca (const T&);
			bool push (const T&);
			void inserimento (const T&);		
			void eliminazione (const int);
			void stampavideo();
			
			void stampafile() const;
			void leggifile(Vettore&);
	};	
}
#endif

Vettore.cpp
#include "Vettore.h"


namespace miospazio
{
	void Vettore::bubblesort ()
	{
		
		for (int i=1; i<riempimento; i++)
		{
			for (int j=0; j<riempimento-i; j++)
			{
				if (vet[j]->get_codice() > vet[j+1]->get_codice())
				{
					T temp;
					temp = vet[j];
					vet[j] = vet[j+1];
					vet[j+1] = temp;
				}
			}
		}
	}
	
	bool Vettore::ricerca (const T& a) 
	{
		bool trovato = false;
		int i = 0;
		while (i<riempimento && trovato == false)
		{
			if (a->get_codice()==vet[i]->get_codice())
			{
				trovato = true;
			}
			else i++;
		}
		return trovato;	
	}
	
	bool Vettore::push (const T& a)
	{
		if (full()) return false;
		else 
		{
			vet[riempimento] = a;
			riempimento++;
			return true;
		}
	}
	
	void Vettore::inserimento (const T& a)
	{
		if (ricerca(a)==false)
		{
			push (a);
			bubblesort();	
		}
		else cout << "Errore codice già presente nell'elenco";
		
	}


	void Vettore::eliminazione (const int C)
	{
		bool trovato = false;
		int i = 0;
		
		while (i<riempimento && trovato == false)
		{
			if (vet[i]->get_codice()==C)
			{
				vet[i] = vet[riempimento-1];
				riempimento--;
				bubblesort();
				trovato = true;
			}
			else i++;
		}
		
		
		if (trovato==true)
		cout << "\nL'elemento di codice " << C << " e' stato eliminato con successo\n";	
	}
	
	void Vettore::stampavideo ()
	{
		for (int i=0; i<riempimento; i++)
		{
			cout << *vet[i];
			cout << "\n";
		}
		
	}
	
	void Vettore::stampafile () const
	{
		ofstream file;
		file.open("output.txt");
	
		for (int i=0; i<riempimento; i++)
		{
			vet[i]->memorizza_dati(file);
			file << "\n___________________________\n";
		}
		
	}	
	
	void Vettore::leggifile()
	{
		ifstream file;
		file.open("input.txt");
		
		if (!file)	cout << "\nErrore aperture file";
		else 
		{
			int i = 0;
			while(!file.eof())
			{
				
			 	vet[i]->visualizza_dati(file);
				i++;
			}
			file.close();	
		}	
	}
}

**shodan** · 30-09-2018, 11:34

in Vettore::leggifile() non imposti la variabile riempimento, che poi vai a usare in Vettore::stampavideo (e altrove).
Suggerimento: è meglio usare std::string e non char* per la gestione delle stringhe (risparmi un bel po' di codice e problemi).

**Mrhide1** · 30-09-2018, 20:04

Ah e quindi nella stampa a video riempimento mi rimane a zero, non stampando così nulla. Ho pensato, visto che nel main chiamo il costruttore della classe Vettore che pone riempimento = 0, utilizzo proprio quest'ultima in quel while al posto dell'indice i. Dopodiché dopo la lettura della Lettera da file lo incremento in modo che possa passare diciamo alla successiva Lettera del file.

codice:

void Vettore::leggifile()
	{
		ifstream file;
		file.open("input.txt");
		
		if (!file)	cout << "\nErrore aperture file";
		else 
		{
			while(!file.eof())
			{
			 	vet[riempimento]->visualizza_dati(file);
				riempimento++;
			}
			file.close();	
		}	
	}

Se era questa la modifica che doveva fare, neanche mi funziona. Per il suggerimento che mi hai dato hai perfettamente ragione, purtroppo la professoressa nelle tracce d'esame impone particolari condizioni come appunto variabili membro di un certo tipo piuttosto che un altro.

**shodan** · 30-09-2018, 22:50

Ma dove crei gli oggetti che dovrebbero popolare vet prima di invocare la leggifile? Possibile che non hai nemmeno un crash?

**Mrhide1** · 01-10-2018, 10:08

Neanche mezzo crash, se sapessi come si fa ti posterei un video. Il copione è sempre lo stesso: si apre la finestra nera, attimo di titubanza come se stesse facendo qualcosa, poi non stampa nulla ed esce programma terminato come se avesse completato l'operazione. Ho provato anche ad usare un vettore già riempito precedentemente, quindi che non è vuoto ma ha già diciamo gli alloggi per gli oggetti da inserire e devo quindi solo sovrascriverli con quelli presenti nel file ma neanche funziona. A questo punto veramente non so più cosa fare, cioè mi è diventato talmente ostico questo problema che ho avuto il tempo di fare almeno altri 6 programmi (ovviamente senza lettura da file) utilizzando vettori o code rappresentate tramite vettori.

**shodan** · 01-10-2018, 18:21

attimo di titubanza come se stesse facendo qualcosa

quello è il crash.

Ho provato anche ad usare un vettore già riempito precedentemente, quindi che non è vuoto ma ha già diciamo gli alloggi per gli oggetti da inserire e devo quindi solo sovrascriverli con quelli presenti nel file ma neanche funziona.

Dipende da come lo hai riempito. A ogni modo così funziona (a parte una imprecisione dovuta al modo sbagliato di usare file.eof() ).
A te ora adattare il codice per le tue esigenze

codice:

void Vettore::leggifile()
{
    ifstream file;
    file.open("input.txt");

    if (!file)    cout << "\nErrore aperture file";
    else
    {
        int i = 0;
        while (!file.eof())
        {
            Manoscritto* p = new Lettera{};
            vet[riempimento] = p;
            vet[riempimento]->visualizza_dati(file);
            riempimento++;
        }
        file.close();
    }
}

**Mrhide1** · 10-10-2018, 11:08

Hai sbagliato a scrivere lì dove hai messo "new Lettera{}" oppure è voluta la cosa? supponendo che tu abbia sbagliato a scrivere ho usato il tuo codice è sostituito con Manoscritto. Infine ho aggiunto nel while "&& riempimento < MAX" visto che il vettore è statico e la sua massima dimensione raggiungibile è MAX = 10. Adesso mi stampa questo però:
11 Leopardi 23 Peppe
0 0
0 0
0 0
0 0
0 0
0 0
0 0
0 0
0 0
Finalmente qualcosa mi viene stampato, peccato che fa questa cosa come se non trovasse la file del file perchè escono fuori 10 posizioni.

**shodan** · 10-10-2018, 18:55

Originariamente inviata da Mrhide1

Hai sbagliato a scrivere lì dove hai messo "new Lettera{}" oppure è voluta la cosa?

Più o meno voluta, nel senso che Lettera{} equivale a Lettera() che equivale a Lettera. In pratica è sempre chiamato il costruttore di default.

...ho usato il tuo codice e sostituito con Manoscritto...
...Adesso mi stampa questo però: ...

Perché c'è una grossa differenza tra la visualizza_dati() di Manoscritto e visualizza_dati() di Lettera. Se usi la prima (e non capisco il perché se invece devi usare Lettera) lo stream va in errore.

Modifica così e vedi quanti conteggi fai:

codice:

void Vettore::leggifile()
{
    ifstream file;
    file.open("sd.txt");

    if (!file)    cout << "\nErrore aperture file";
    else
    {
        // int i = 0; non usata
        while (file.good() && riempimento < MAX) // .good() non .eof()
        {
            Manoscritto* p = new Manoscritto; // new Lettera;
            vet[riempimento] = p;
            vet[riempimento]->visualizza_dati(file);
            riempimento++;
        } ;
        if (!file.good()) riempimento--; // evita la lettura doppia dell'ultima riga.
        file.close();
    }
}

Discussione: [C++] Problema Lettura da File ADT vettore

Strumenti discussione

Ricerca discussione

Visualizza

Permessi di invio