DOMANDA Come faccio a creare un vettore ad oggetti di due tipi contemporaneamente?

Pubblicità
Mr.Cobra

Mr.Cobra

Nuovo Utente
Messaggi
69
Reazioni
1
Punteggio
26
Ciao lo so ciò che ho detto forse non ha senso.
Ho un problema e non riesco a risolvere, ho aperto questo topic non tanto cercare aiuti sul sistemare il mio programma (vorrei farlo da solo ma se mi date un consiglio mentre vedete il programma mi fa piacere) ma più che altro sullo sviluppo dell'algoritmo del mio problema, vi metto nel topic anche il mio programma.

L'obbiettivo di questo esercizio è gestire un mobile libreria la sua capienza è di 50 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 e naturalmente in una determinata posizione non ci possono essere sia un libro di tipo scienza ne uno di letteratura.

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?

Qui nasce il problema non sono come creare un vettore di 50 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' il mio primo programma ad oggetti quindi non so se sia pieno di bug perchè non ho compilato perchè mi sono bloccato su come creare l'algoritmo e quindi non è completo, avrei bisogno di consigli e poi cerco di debugarlo da solo.

Libreria Libro.h

C++: 
#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.ccp:

C++: 
#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 Scientifica.h:

C++: 
#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


Funzioni Scienfico.ccp

C++: 
#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 :

C++: 
#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


Funzioni Letteratura.h

C++: 
#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 Libreri.h

C++: 
#ifndef LIBRERIA_H
#define LIBRERIA_H

#include "Scientifico.h"
#include "Letteratura.h"

namespace Libreria{

    class Libreria:public Scientifico, public Letteratura{
 


    };

}


#endif
 
Ci sono svariati, ma svariati errori.
Innanzitutto bisonga differenziare gli oggetti del tipo istream da quelli del tipo ostream. Una funzione del tipo read richiede sicuramente un oggetto del tipo istream su cui operare. Tu stai chiedendo come parametro un oggetto istream senza però utilizzarlo, utilizzando invece l'oggetto cin e tra l'altro emettendo output su cout. Una funzione read non deve permettersi di scrivere. Le funzioni print mi sembrano invece corrette tranne discordanze tra il prototipo e la dichiarazione.

Stai evidentemente utilizzando C++ e utilizzi ancora come stringhe le null-terminated invece di oggetti basic_string che nei costruttori metti come opzionale inizializzandolo a 0 e non a nullptr, senza contare di nessun costruttore rvalue reference e di funzioni const. Stai anche utilizzando strane convenzioni per i nomi: Scientifico dovrebbe essere LibroScientifico e stessa cosa per Letteratura.

Poi l'ereditarietà. Santa ereditarietà. Che alcuni oggetti siano anche altri oggetti va bene, ma non è la soluzione a tutto. Una libreria non è un libro. Non è né un libro scientifico, né storico, né chissaché. Una libreria contiene libri. Contiene array di libri, che possano essere vettori o a due dimensioni (quindi scaffali). Ma non è un libro. LibroScientifico è un Libro, ma devi chiamare il costruttore di Libro in LibroScientifico, come in LibroLetteratura.

Quindi per concludere:
C++: 
class Libro  
{
public:
    Libro() = default;
 };
class LibroScientifico : public Libro 
{
public:
    LibroScientico()
        : Libro() // chiamata al costruttore di Libro
    { }
 };
class LibroLetteratura : public Libro
{
public:
    LibroLetteratura() = default; // chimata implicita a Libro()
};
class Libreria
{
private:
    std::vector<Libro> libri;
...
};
Poi il poliformismo farà il suo lavoro
 
_Achille ha detto:
Poi l'ereditarietà. Santa ereditarietà. Che alcuni oggetti siano anche altri oggetti va bene, ma non è la soluzione a tutto. Una libreria non è un libro. Non è né un libro scientifico, né storico, né chissaché. Una libreria contiene libri. Contiene array di libri, che possano essere vettori o a due dimensioni (quindi scaffali). Ma non è un libro. LibroScientifico è un Libro, ma devi chiamare il costruttore di Libro in LibroScientifico, come in LibroLetteratura.

Quindi per concludere:
C++: 
class Libro
{
public:
    Libro() = default;
};
class LibroScientifico : public Libro
{
public:
    LibroScientico()
        : Libro() // chiamata al costruttore di Libro
    { }
};
class LibroLetteratura : public Libro
{
public:
    LibroLetteratura() = default; // chimata implicita a Libro()
};
class Libreria
{
private:
    std::vector<Libro> libri;
...
};
Poi il poliformismo farà il suo lavoro
Clicca per espandere...

Grazie mille per i consigli, capisco che la mia ignoranza ti faccia arrabbiare :asd:
Pero era questa la mia intensione non volevo creare un libreria libreria.h che fosse derivata da Libro, Scientifico e Letteratura.
Volevo solo usarli come oggetti della classe Libreria e non sapevo come impostare il codice grazie di questi consigli.

Ci sono svariati, ma svariati errori.
Innanzitutto bisonga differenziare gli oggetti del tipo istream da quelli del tipo ostream. Una funzione del tipo read richiede sicuramente un oggetto del tipo istream su cui operare. Tu stai chiedendo come parametro un oggetto istream senza però utilizzarlo, utilizzando invece l'oggetto cin e tra l'altro emettendo output su cout. Una funzione read non deve permettersi di scrivere. Le funzioni print mi sembrano invece corrette tranne discordanze tra il prototipo e la dichiarazione.

Stai evidentemente utilizzando C++ e utilizzi ancora come stringhe le null-terminated invece di oggetti basic_string che nei costruttori metti come opzionale inizializzandolo a 0 e non a nullptr, senza contare di nessun costruttore rvalue reference e di funzioni const. Stai anche utilizzando strane convenzioni per i nomi: Scientifico dovrebbe essere LibroScientifico e stessa cosa per Letteratura.
Clicca per espandere...

Per quanto riguarda il codice non l'ho messo per farmelo correggere, l'ho messo perchè volevo far capire come stessi lavorando, anzi speravo per quanto ne possa capire di continuarlo a debugarlo da solo così mentre lo faccio mi ripeto un pò di teoriae migliorare attraverso i miei errori.
Grazie per il consiglio sul null e su istream scusami per l'ignoranza cercherò di migliorare.

Solo una cosa se puoi, nel mio corso e sul mio libro non c'è questo tipo di istruzione:
C++: 
std::vector<Libro> libri;
Mi sono andato a leggere il capitolo sui template del mio stesso corso da più crediti e credo che dovrebbe essere basato su questo.
Non potrei usarli vorrei basarmi su quello che ha spiegato la prof se facessi così? non voglio dire una cagata, posso?
C++: 
typedef Libro* pntLibro;

class Libreria{
    
    public:
    static const int N=100;       
    pntLibro vett[N];           
    int cont;
 
Ultima modifica:
Mr.Cobra ha detto:
Grazie mille per i consigli, capisco che la mia ignoranza ti faccia arrabbiare :asd:
Pero era questa la mia intensione non volevo creare un libreria libreria.h che fosse derivata da Libro, Scientifico e Letteratura.
Volevo solo usarli come oggetti della classe Libreria e non sapevo come impostare il codice grazie di questi consigli.



Per quanto riguarda il codice non l'ho messo per farmelo correggere, l'ho messo perchè volevo far capire come stessi lavorando, anzi speravo per quanto ne possa capire di continuarlo a debugarlo da solo così mentre lo faccio mi ripeto un pò di teoriae migliorare attraverso i miei errori . Grazie per il consiglio sul null e su istream scusami per l'ignoranza cercherò di migliorare.
Clicca per espandere...
Ma va quale arrabbiare :asd:

C++ è C++ e non è C. Quindi evita di utilizzare char * come stringhe.
Un piccolo consiglio: evita classi intrigate com ereditarietà prima di aver appreso certe nozioni. Soprattutto studia la STL e inizia ad utilizzare std::unique_ptr al posto di puntatori nudi e crudi.
 
Voglio studiarmeli comunque i template per conto mio comunque e vorrei migliorare la mia preparazione da solo del c++ dopo il mio esame di programmazione hai dei consiglio pensavo di prendere più in là Tecniche avanzate di deitel & deitel hai consigli da darmi? Mi hanno detto che nel modo dei videogame si usa molto il c++ è vero? In che altri campi si usa molto e lo si preferisce ad altri linguaggi?
 
_Achille ha detto:
Ma va quale arrabbiare :asd:

C++ è C++ e non è C. Quindi evita di utilizzare char * come stringhe.
Un piccolo consiglio: evita classi intrigate com ereditarietà prima di aver appreso certe nozioni. Soprattutto studia la STL e inizia ad utilizzare std::unique_ptr al posto di puntatori nudi e crudi.
Clicca per espandere...

Purtroppo ti ripeto non posso usarli nel mio esame di programmazione perchè vorrei attenermi a quello che hanno spiegato in classe e al programma didattico.
Ho letto il capitolo sui template e gli STL e me ristudierò più approfonditamente per conto mio questo è sicuro perchè sicuramente saranno utili.

Solo una cosa se puoi, nel mio corso e sul mio libro non c'è questo tipo di istruzione:
C++: 
std::vector<Libro> libri;
Mi sono andato a leggere il capitolo sui template del mio stesso corso da più crediti e credo che dovrebbe essere basato su questo.
Non potrei usarli vorrei basarmi su quello che ha spiegato la prof se facessi così? non voglio dire una cagata, posso?
C++: 
typedef Libro* pntLibro;

class Libreria{
  
    public:
    static const int N=100;     
    pntLibro vett[N];         
    int cont;
 
Ti rispondo solo a questo, lascio poi ad _Achille il resto.

Mr.Cobra ha detto:
C++: 
std::vector<Libro> libri;
Mi sono andato a leggere il capitolo sui template del mio stesso corso da più crediti e credo che dovrebbe essere basato su questo.
Non potrei usarli vorrei basarmi su quello che ha spiegato la prof se facessi così? non voglio dire una cagata, posso?
C++: 
typedef Libro* pntLibro;

class Libreria{

    public:
    static const int N=100;   
    pntLibro vett[N];       
    int cont;
Clicca per espandere...

Visto che usi la OOP, dovresti evitare quel puntatore. Per allocare memoria si usa l'operatore 'new'... e quell'array dovresti allocarlo con new (e non lì, visto che mi sembra più l'header).

C++: 
Libro *libro = new Libro[n];

vector rappresenta un array dinamico. In pratica è un normalissimo array con una determinata capienza (spesso viene scelta una dimensione di 10 elementi) che una volta esaurita provoca la creazione di un nuovo array più grande e la copia degli elementi del vecchio vettore all'interno del nuovo.
Di solito quando non si conosce il numero degli elementi dei quali si necessita, si utilizza vector (o qualcosa di simile).
 
DispatchCode ha detto:
Ti rispondo solo a questo, lascio poi ad _Achille il resto.



Visto che usi la OOP, dovresti evitare quel puntatore. Per allocare memoria si usa l'operatore 'new'... e quell'array dovresti allocarlo con new (e non lì, visto che mi sembra più l'header).

C++: 
Libro *libro = new Libro[n];

vector rappresenta un array dinamico. In pratica è un normalissimo array con una determinata capienza (spesso viene scelta una dimensione di 10 elementi) che una volta esaurita provoca la creazione di un nuovo array più grande e la copia degli elementi del vecchio vettore all'interno del nuovo.
Di solito quando non si conosce il numero degli elementi dei quali si necessita, si utilizza vector (o qualcosa di simile).
Clicca per espandere...

Si so come si alloca dinamicamente un vettore lo anche fatto nel programma quindi alloca normalmente il mio array all'interno della
C++: 
struct
.

Volevo chiedervi una cosa io questo tipo di chiamata non l'ho mai visto fare :

C++: 
class LibroLetteratura : public Libro
{
public:
    LibroLetteratura() = default; // chimata implicita a Libro()
};

Il valore
Codice: 
default
cosa fa? Inizializza tutto a 0 c'è un modo per impostarlo? Ad esempio facciamo conto che ho un oggetto composto da una stringa voglio inizializzarlo a default e che sia contente la stringa "stringa vuota" sapete dirmi di più?
 
In questo contesto lascia stare i Template, ti confondono le idee.

Ti hanno gia' dato ottimi consigli, che sottoscrivo. Aggiungo una piccola nota educativa.

L'ereditarieta' e' una bella cosa, ma bisogna non solo capirla, ma capire quando usarla.
Un libro scientifico e' un libro, quindi ha senso definire una classe per un libro scientifico. Ma in genere si utilizza una classe solo se si vuole ampliare un classe gia' presente, non quando si vuole aggiungere una "proprieta'". In questo caso, puoi semplicemente aggiungere una stringa alla classe libro (come autore e titolo) e chiamarla semplicemente "Genere" e sei a posto (o come alternativa definire un Enum). Spetta a te decidere (dipende dal contesto). Di fatto non hai dichiarato una classe per tutti i libri di uno stesso autore :) Lo stesso vale per molte altre "proprieta'" di un libro che sono "comuni" a tutti i libri. Per esempio il prezzo, il tipo di copertina, il numero di pagine, l'editore e cosi' via.
 
Mr.Cobra ha detto:
Voglio studiarmeli comunque i template per conto mio comunque e vorrei migliorare la mia preparazione da solo del c++ dopo il mio esame di programmazione hai dei consiglio pensavo di prendere più in là Tecniche avanzate di deitel & deitel hai consigli da darmi? Mi hanno detto che nel modo dei videogame si usa molto il c++ è vero? In che altri campi si usa molto e lo si preferisce ad altri linguaggi?
Clicca per espandere...
Te lo sconsiglio. Il libro è eccezionale certo, ma risale al C++03 quando ora abbiamo il C++17 e tra non moltissimo C++20 che è cambiato un sacco
Giacomo Furlan ha detto:
Principale motivo per il quale gli sviluppatori ribaltano il tavolo e cambiano linguaggio :D
Clicca per espandere...
Dai alla fine la complessità non è assurda. Non spaventiamolo così :asd:
Mr.Cobra ha detto:
Purtroppo ti ripeto non posso usarli nel mio esame di programmazione perchè vorrei attenermi a quello che hanno spiegato in classe e al programma didattico.
Ho letto il capitolo sui template e gli STL e me ristudierò più approfonditamente per conto mio questo è sicuro perchè sicuramente saranno utili.

Solo una cosa se puoi, nel mio corso e sul mio libro non c'è questo tipo di istruzione:
C++: 
std::vector<Libro> libri;
Mi sono andato a leggere il capitolo sui template del mio stesso corso da più crediti e credo che dovrebbe essere basato su questo.
Non potrei usarli vorrei basarmi su quello che ha spiegato la prof se facessi così? non voglio dire una cagata, posso?
C++: 
typedef Libro* pntLibro;

class Libreria{

    public:
    static const int N=100;
    pntLibro vett[N];    
    int cont;
Clicca per espandere...
Inizia ad utilizzare using invece di typedef, sarebbe quindi using ptrLibro = Libro *. Inoltre qui è lavoro della allocazione dinamica quindi:
C++: 
class Libro { };

class Libreria
{
private:
    Libro* ptr;
    size_t size; // stdlib.h/cstdlib
public:
    Libreria(size_t s)
        : size(s),
        ptr(new Libro[size])
    { }
    Libreria()
        : Libreria(50)
    { }
};
È molto importante ricordarsi nel distruttore:
C++: 
~Libreria()
    {
        ...
        delete[] ptr;
    }
In alternativa un bel unique_ptr:
C++: 
class Libreria
{
private:
    unique_ptr<Libro> ptr;
    size_t size; // stdlib.h/cstdlib
public:
    Libreria(size_t s)
        : size(s),
        ptr(make_unique<Libro>(size))
    { }
    Libreria()
        : Libreria(50)
    { }
    ~Libreria()
    {
        ...
    }
};
Come vedi non devi distruggere tu il puntatore. Ma pensa che con un std::vector avevi pure push_back(), pop_back(), resize() ecc...
Mr.Cobra ha detto:
C++: 
class LibroLetteratura : public Libro
{
public:
    LibroLetteratura() = default; // chimata implicita a Libro()
};

Il valore
Codice: 
default
cosa fa? Inizializza tutto a 0 c'è un modo per impostarlo? Ad esempio facciamo conto che ho un oggetto composto da una stringa voglio inizializzarlo a default e che sia contente la stringa "stringa vuota" sapete dirmi di più?
Clicca per espandere...
Un costruttore scritto come Costruttore() = default; crea il costruttore in modo implicito. Utile quando hai un costruttore alternativo che cancella il costruttore di default. Esiste anche il delete: Costruttore(Costruttore&&) = delete, cancella in questo caso il costruttore rvalue reference. Il costruttore default dovrebbe inizializzare la stringa C-Type a nullptr -> invece non crea l'oggetto.
Ah no la chiamata implicita è al costruttore di Libro. Un costruttore default chiama in modo implicito il costruttore della superclasse
 
Ultima modifica:
Andretti60 ha detto:
In questo contesto lascia stare i Template, ti confondono le idee.

Ti hanno gia' dato ottimi consigli, che sottoscrivo. Aggiungo una piccola nota educativa.

L'ereditarieta' e' una bella cosa, ma bisogna non solo capirla, ma capire quando usarla.
Un libro scientifico e' un libro, quindi ha senso definire una classe per un libro scientifico. Ma in genere si utilizza una classe solo se si vuole ampliare un classe gia' presente, non quando si vuole aggiungere una "proprieta'". In questo caso, puoi semplicemente aggiungere una stringa alla classe libro (come autore e titolo) e chiamarla semplicemente "Genere" e sei a posto (o come alternativa definire un Enum). Spetta a te decidere (dipende dal contesto). Di fatto non hai dichiarato una classe per tutti i libri di uno stesso autore :) Lo stesso vale per molte altre "proprieta'" di un libro che sono "comuni" a tutti i libri. Per esempio il prezzo, il tipo di copertina, il numero di pagine, l'editore e cosi' via.
Clicca per espandere...

Grazie per i consigli ma l'esercizio mi chiedeva proprio espressamente di creare delle classi derivate Scientifico e Letteratura da quella base Libro, va benissimo lo terrò a mente il consiglio :ok:
 
Te lo sconsiglio. Il libro è eccezionale certo, ma risale al C++03 quando ora abbiamo il C++17 e tra non moltissimo C++20 che è cambiato un sacco
Clicca per espandere...

Com'è il C++20 il mio forse sta all'undici, ma in che cosa è meglio Java e in cosa è meglio C++? In che campi si preferisce usare uno oppure un altro? Di certo non voglio certo non voglio chiederti tutte le nuove migliorie del C++17, ma sono molto curioso, come è cambiato rispetto a credo al C++ che sto studiando? Ci sono sbocchi per chi sa programmare bene in c++? Ci sono manuali in giro? Vorrei farmi una lista di libri da leggere dopo aver fatto l'esame come mio hobby tu cosa mi consigli di mettere nella lista? Ci vuole molto per padroneggiare il C++17? Tu quanto tempo ci hai messo? Si riescono a trovare lavori da fare e affiancarli allo studio?Altri consigli da darmi?
 
E invece il C# che differenze ha con il C++? Io ora sto usando il DevC++ come compilatore obbligato dalla mia università tutti mi dicono che fa cagare cosa mi consigliate?
 
Pubblicità
Pubblicità
Indietro
Top