Svolgiamo insieme Esame 2 marzo 2015 della vittorini programma Garage

[Quentin Tarantino]

Sto cercando di completare un programma modulare ad oggetti, ma mi sono bloccato, mi date una mano?
(E' il mio primo programma ad oggetti quindi può essere un casino perchè non ho compilato perchè mi sono bloccato su come creare l'algoritmo e quindi non è completo, se avete bisogno di precisazioni sul codice ditemelo non c'è problema)
Lo scopo di questo esercizio è gestire un parcheggio, la sua capienza è di 20 veicoli, i veicoli possono essere di due tipi o motociclette o automobili.
Le tre classi sono formate da variabili membro, stringhe allocate dinamicamente, e con le seguenti caratteristiche :

-Veicolo classe Base (Nome e Marca)
-Motocicletta classe derivata da veicolo (Tipo)
-Automobile classe derivata da veicolo (Alimentazione)

Gli oggetti Motocicletta o Automobile devono essere creati dinamicamente nel main attraverso un sistema di scelte.

Ho trovato problemi nella creazione della classe Paracheggio, ho pensato di creare una classe Parcheggio di tipo vettoriale ma mi sono bloccato perchè non so come creare un vettore che contenga o un oggetto motocicletta o un oggetto di tipo automobili consigli?

Questo è il mio codice:

Libreria Veicolo.h:

#ifndef VEICOLO_H
#define VEICOLO_H

#define N 100

#include <iostream>
#include <cstring>

using namespace std;

namespace Parcheggio{
    typedef char Buffer [N];
 
    class Veicolo{
        friend ostream & operator<<(ostream &,const Veicolo &);
        friend istream & operator>>(istream &, Veicolo &);
     
        public:
        Veicolo(const char * = 0, const char * = 0);
        Veicolo(const Veicolo&);
        ~Veicolo()
         
        void set_Veicolo(const char *,const char *);
        void set_Nome(const char *);
        void set_Marca(const char *);
        char *get_Nome() const {return Nome};
        char *get_Marca() const {return Marca};
        bool operator==(const Veicolo &);
     
        protected:
        virtual ostream &print(ostream &) const;
        virtual istream &read(istream &);
     
        private:
        char *Nome;
        char *Marca;
    };
}
#endif

Funzioni Veicolo:

#include "Veicolo.h"

namespace Garage{

    Veicolo::Veicolo(const char *N, const char *M) { set_Veicolo(N, M); }

    Veicolo::Veicolo(const Veicolo &V) { set_Veicolo(V.Nome, V.Marca); }

    void Veicolo::set_Veicolo(const char *N, const char *M){
        set_Nome(N);
        set_Marca(M);
    }

    void Veicolo::set_Nome(const char *N){
        Nome= new char [strlen(N)+1];
        strcpy(Nome, N);
    }

    void Veicolo::set_Marca(const char *M){
        Marca=new char [strlen(M)+1];
        strcpy(Marca, M);
    }

    Veicolo::~Veicolo(){
        delete [] Nome;
        delete [] Marca;
    }

    istream &Veicolo::print(istream &out){
        out<<"Veicolo nome :"<<Nome<<" | Marca :"<<Marca;
        return out;
    }

     istream &Veicolo::read(istream &in){
         Buffer b1, b2;
        cout<<"\n Inserisci il nome del Veicolo: ";
        cin.getline(b1, N-1, '\n');
        cout<<"\n Inserisci la marca del Veicolo: ";
        cin.getline(b2, N-1, '\n');
        set_Veicolo(b1, b2);
        return in;
    }



    ostream &operator<<(ostream &out, const Veicolo &V){
        V.print(out);
        return out;
    }

    istream &operator>>(istream &in, const Veicolo &V){
        V.read(in);
        return in;
    }

    bool Veicolo::operator==(const Veicolo &V){
        if(strcmp(Nome, V.Nome)==0&&strcmp(Marca, V.Marca)==0){
            return true;
        }else return false;
     }

}

Libreria Motocicletta.h

#ifndef MOTOCICLETTA_H
#define MOTOCICLETTA_H

#include "Veicolo.h"

using namespace Parcheggio{

    class Motocicletta: public virtual Veicolo{

        friend ostream &operator<<(ostream &, const Motocicletta &);
        friend istream &operator>>(istream &, const Motocicletta &);

        public:
            Motocicletta(const char * = 0, const char * = 0, const char *=0);
            Motocicletta(const Motocicletta &);
            ~Motocicletta();

            void set_Mototipo(const char *);
            char *get_Mototipo() {return Mototipo};

            bool operator==(const Motocicletta &);

        protected:

            virtual ostream &print(ostream &)const;
            virtual istream &read(istream &);

        private:
            char *Mototipo;

};

}
#endif

Motociletta funzioni:

#include "Motocicletta.h"

using namespace Parcheggio{

   Motocicletta::Motocicletta(const char *N, const char *M, const char *MO_T):Veicolo(N, M) { set_Mototipo(MO_T); }

   Motocicletta::Motocicletta(const Motorbike& MO):Vehicle(MO) { set_Mototipo(MO.Mototipo); }

    void Motocicletta::set_Mototipo(const char *MO_T){
        Mototipo= new char [strlen(MO_T)+1];
        strcmp(Mototipo, MO_T);
    }

    ~Motocicletta::Motocicletta() {delete [] Mototipo; };

    ostream &Motocicletta::print(ostream &out)const {
    Veicolo::print(out);
    out<<"|Type : "<<Mototipo;
    return out;
    }

    istream &Motocicletta::read(istream &in){
        Buffer b;
        Veicolo::read(in);
        cout<<"\n Inserisci il tipo di Motocicletta :";
        cin.getline(b, N-1, '\n');
        set_Mototipo(b);
        return in;
    }

    ostream &operator<<(ostream &out, const Motocicletta & MO){
        MO.print(out);
        return out;
    }

    istream &operator>>(istream &in, const Motocicletta & MO){
        MO.read(in);
        return in;
    }

    bool Motocicletta::operator==(Motocicletta &MO){
        if(Motocicletta::operator==(MO)&&strcmp(Mototipo, MO.Mototipo)==0);{
        return true;
        }else return false;
    }



}

Libreria Automobile.h:

#ifndef AUTOMOBILE_H
#define AUTOMOBILE_H

#include "Veicolo.h"

using namespace Parcheggio{

    class Automobile: public virtual Veicolo{
   
    friend ostream &operator<<(ostream &, const Automobile&);
    friend istream &operator>>(istream &, const Automobile&);
   
    public:
        Automobile(const char * =0, const char * =0, const char *=0)
        Automobile(const Automobile&);
        ~Automobile();
       
        void set_Alimentazionetipo(const char *);
        char *get_Alimentazionetipo() { return Alimentazionetipo};
        bool operator==(const Automobile&);
       
    protected:
        virtual ostream &print(ostream &out);
        virtual istream &read(istream &in);
   
    private:
        char *Alimentazionetipo;
       
    };
}
#endif

Automobile funzioni:

#include "Automobile.h"

using namespace Parcheggio{
    Automobile::Automobile(const char *N, const char *M, const char *A_T):Veicolo(N, M){ set_Alimentazionetipo(A_T); }
    
    Automobile::Automobile(const Automobile &A):Veicolo(A){ set_Alimentazionetipo(A.Alimentazionetipo); }
    
    void Automobile::set_Alimentazionetipo(const char *A_T){
        Alimentazionetipo= new char [strlen(A_T)+1];
        strcpy(Alimentazionetipo, A_T);
    }
    
    ~Automobile::Automobile(){delete [] Alimentazionetipo;}
    
    ostream &Automobile::print(ostream &out){
        Veicolo::print(out);
        out<<"|Tipo di alimentazione : "<<Alimentazionetipo;
        return out;
    }
    
    isteram &Automobile::read(ostream &in){
        Buffer b;
        Veicolo::read(in);
        cin.getline(b, N-1, '\n');
        set_Alimentazionetipo(b);
        return in;
    }
    
    ostream &operator<<(ostream &out, const Automobile & A){
        V.print(out);
        return out;
    }
    
    istream &operator<<(istream &in, const Automobile &A){
        V.read(in);
        return in;
    }
    
    bool Automobile::operator==(const Automobile &A){
        if(Veicolo::operator==(A)&&strcmp(Alimentazionetipo, A.Alimentazionetipo)==0){
            return true;
        }else return false;
    }
    
}

Libreria Parcheggio.h

#ifndef PARCHEGGIO_H
#define PARCHEGGIO_H

#include "Motociletta.h"
#include "Automobile.h"

namespace Parcheggio{

    class Parcheggio:public Automobile, public Motocicletta{



    };

}


#endif

Qui nasce il problema non sono come creare un vettore di 20 elementi che possa contenere in una determinata posizione o un elemento di tipo Motocicletta o di tipo Automobile, avevo pensato ad una struct con due vettori uno di un tipo Motocicletta e uno di tipo automobile che se ad esempio alla posizione 5 del vettore motocicletta è occupata da un ogetto, alla stessa posizione l'oggetto del vettore Automobile era inizializzata con il costruttore di default a 0 però è un pò bruttina come soluzione. Avete qualche soluzione un pò più elegante da consigliarmi? Ci sono molti errori nel mio programma?