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();
}
}
}