Ciao a tutti sto cercando di risolvere un esercizio di programmazione ad oggetti ma trovo sto trovando problemi nello sviluppo dell'ultima parte del mio algoritmo.
Lo scopo di questo esercizio è gestire una libreria a muro, la sua capienza è di 100 libri, i libri possono essere di due tipi o scientifici o di letteratura.?
Le tre classi sono formate da variabili membro, stringhe allocate dinamicamente, e con le seguenti caratteristiche :?
?
-Libro classe Base (Autore e Editore)?
-Scientifico classe derivata da libro (Ramo)?
-Letteratura classe derivata da libro (Genere)?
?
Gli oggetti Scientifici o Letteratura devono essere creati dinamicamente nel main attraverso un sistema di scelte.?
?
Ho trovato problemi nella creazione della classe Libreria, ho pensato di creare una classe Libreria di tipo vettoriale ma mi sono bloccato perchè non so come creare un vettore che contenga o un oggetto scientifico o un oggetto di tipo letteratura consigli?
?(Naturalmente in una determinata posizione non ci può essere un oggetto contemporaneamente Scientifico e Letteratura)
Qui nasce il problema non sono come creare un vettore di 100 elementi che possa contenere in una determinata posizione o un elemento di tipo Scientifico o di tipo Letteratura, avevo pensato ad una struct con due vettori uno di un tipo Scientifico e uno di tipo Letteratura che se ad esempio alla posizione 5 del vettore Scientifico è occupata da un oggetto, alla stessa posizione l'oggetto del vettore Letteratura era inizializzata con il costruttore di default a 0 però è un pò bruttina come soluzione. Avete qualche soluzione un pò più efficace da consigliarmi? ?
E' uno dei miei primi programmi ad oggetti quindi non so se sia perfettamente non pieno di bug perchè non ho compilato perchè mi sono bloccato su come creare l'algoritmo e quindi non è completo.
Non vi chiedo di mettere mano al ?codice ci voglio pensare io a debugarlo ve lo allego per farvi avere un idea su ciò che sto realizzando, ciò che mi serve e soprattutto avere consigli sullo sviluppo dell'ultima parte dell'algoritmo.
Libreria Libro.h:?
#ifndef LIBRO_H
#define LIBRO_H
#define N 100
#include <iostream>
#include <cstring>
using namespace std;
namespace Libreria{
typedef char Buffer [N];
class Libro{
friend ostream & operator<<(ostream &,const Libro &);
friend istream & operator>>(istream &, Libro &);
public:
Libro(const char * = 0, const char * = 0);
Libro(const Libro&);
~Libro()
void set_Libro(const char *,const char *);
void set_Autore(const char *);
void set_Editore(const char *);
char *get_Autore() const {return Autore};
char *get_Editore() const {return Editore};
bool operator==(const Libro &);
protected:
virtual ostream &print(ostream &) const;
virtual istream &read(istream &);
private:
char *Autore;
char *Editore;
};
}
#endif
Funzioni Libro:
#include "Libro.h"
namespace Libreria{
Libro::Libro(const char *A, const char *E) { set_Libro(A, E); }
Libro::Libro(const Libro&L) { set_Libro(L.Autore, L.Editore); }
void Libro::set_Libro(const char *A, const char *M){
set_Autore(A);
set_Editore(M);
}
void Libro::set_Autore(const char *A){
Autore= new char [strlen(A)+1];
strcpy(Autore, A);
}
void Libro::set_Editore(const char *E){
Editore=new char [strlen(E)+1];
strcpy(Editore, E);
}
Libro::~Libro(){
delete [] Autore;
delete [] Editore;
}
istream &Libro::print(istream &out){
out<<"Libro autore :"<<Autore<<" | Editore :"<<Editore;
return out;
}
istream &Libro::read(istream &in){
Buffer b1, b2;
cout<<"\n Inserisci l'autore del Libro: ";
cin.getline(b1, N-1, '\n');
cout<<"\n Inserisci l'editore del Libro: ";
cin.getline(b2, N-1, '\n');
set_Libro(b1, b2);
return in;
}
ostream &operator<<(ostream &out, const Libro &L){
L.print(out);
return out;
}
istream &operator>>(istream &in, const Libro &L){
V.read(in);
return in;
}
bool Libro::operator==(const Libro &L){
if(strcmp(Autore, L.Autore)==0&&strcmp(Editore, L.Editore)==0){
return true;
}else return false;
}
}
?
?
Libreria Sceintifo:
#ifndef SCENTIFICO_H
#define SCIENTIFICO_H
#include "Libro.h"
using namespace Libreria{
class Scientifico: public virtual Libro{
friend ostream &operator<<(ostream &, const Scientifico &);
friend istream &operator>>(istream &, const Scientifico &);
public:
Scientifico(const char * = 0, const char * = 0, const char *=0);
Scientifico(const Scientifico &);
~Scientifico();
void set_Ramo(const char *);
char *get_Ramo() {return Ramo};
bool operator==(const Scientifico &);
protected:
virtual ostream &print(ostream &)const;
virtual istream &read(istream &);
private:
char *Ramo;
};
}
#endif
Scientifico funzioni:
#include "Scientifico.h"
using namespace Parcheggio{
Scientifico::Scientifico(const char *A, const char *E, const char *S_R):Veicolo(A, E) { set_Ramo(S_R); }
Scientifico::Scientifico(const Scientifico& S):Libro(S) { set_Ramo(S.Ramo); }
void Scientifico::set_Ramo(const char S_R){
Ramo= new char [strlen(S_R)+1];
strcmp(Ramo, S_R);
}
~Scientifico::Scientifico() {delete [] Ramo; };
ostream &Scientifico::print(ostream &out)const {
Libro::print(out);
out<<"|Ramo : "<<Ramo;
return out;
}
istream &Scientifico::read(istream &in){
Buffer b;
Libro::read(in);
cout<<"\n Inserisci il ramo Scientifico :";
cin.getline(b, N-1, '\n');
set_Ramo(b);
return in;
}
ostream &operator<<(ostream &out, const Scientifico & S){
S.print(out);
return out;
}
istream &operator>>(istream &in, const Scientifico & S){
S.read(in);
return in;
}
bool Scientifico::operator==(Scientifico &S){
if(Scientifico::operator==(S)&&strcmp(Scientifico, S.Scientifico)==0);{
return true;
}else return false;
}
}
Libreria Letteratura.h
#ifndef LETTERATURA_H
#define LETTARATURA_H
#include "Libro.h"
using namespace Libreria{
class Letteratura: public virtual Libro{
friend ostream &operator<<(ostream &, const Letteratura&);
friend istream &operator>>(istream &, const Letteratura&);
public:
Letteratura(const char * =0, const char * =0, const char *=0)
Letteratura(const Letteratura&);
~Letteratura();
void set_Genere(const char *);
char *get_Genere() { return Genere};
bool operator==(const Letteratura&);
protected:
virtual ostream &print(ostream &out);
virtual istream &read(istream &in);
private:
char *Genere;
};
}
#endif
Letteratura funzioni:
#include "Letteratura.h"
using namespace Libreria{
Letteratura::Letteratura(const char *A, const char *E, const char *LET_G):Libro(A, E){ set_Genere(LET_G); }
Letteratura::Letteratura(const Letteratura &LET):Libro(LET){ set_Genere(LET.Genere); }
void Letteratura::set_Genere(const char *LET_G){
Genere= new char [strlen(LET_G)+1];
strcpy(Genere, LET_G);
}
~Letteratura::Letteratura(){delete [] Genere;}
ostream &Letteratura::print(ostream &out){
Libro::print(out);
out<<"|Genere : "<<Genere;
return out;
}
isteram &Letteratura::read(ostream &in){
Buffer b;
Libro::read(in);
cin.getline(b, N-1, '\n');
set_Genere(b);
return in;
}
ostream &operator<<(ostream &out, const Letteratura & LET){
LET.print(out);
return out;
}
istream &operator<<(istream &in, const Letteratura &LET){
LET.read(in);
return in;
}
bool Letteratura::operator==(const Letteratura &A){
if(Libro::operator==(A)&&strcmp(Genere, LET.Genere)==0){
return true;
}else return false;
}
}
Libreria Libreria.h
#ifndef LIBRERIA_H
#define LIBRERIA_H
#include "Scientifico.h"
#include "Letteratura.h"
namespace Libreria{
class Libreria:public Scientifico, public Letteratura{
};
}
#endif