Salve a tutti, avrei un problema con un programma.
Mi viene chiesto di realizzare la gerarchia FileMultimediale, BranoMusicale e Video con classi, e fin qui tutto bene.
Successivamente mi viene chiesto "Si realizzi una coda statica attraverso la quale sia possibile gestire in maniera polimorfa sia elementi di tipo BranoMusicale che di tipo Video e stampare su file testo lo stato della coda. La sessione di scrittura su file viene gestita dalla classe coda, che definisce la variabile di tipo stream. La funzione memorizza_dati si limita a riceverla come parametro di ingresso."

Non so come reallizzare queste due cose. Ho provato a creare una coda statica di con elementi di tipo FileMultimediale, ma non riescoa realizzare il polimorfismo, ovvero, non riesco a usare gli oggetti FileMultimediale come BranoMusicale o Video. Come fare?

Ecco il mio codice:

FileMultimediale.h:
codice:
#ifndef _H_FileMultimediale
#define _H_FileMultimediale
 
#include <iostream>
#include <cstring>
#include <fstream>
using namespace std;
 
class FileMultimediale {
     
      friend ostream & operator<<(ostream &, const FileMultimediale &);
      friend istream & operator>>(istream &, FileMultimediale &);
      protected:
         char * URL;
         int Kbyte;
         char * Formato;
         virtual ostream & print(ostream & os) const;
         virtual istream & insert(istream & in);
      public:
         FileMultimediale(const char * U="", const int K=0, const char * F="");
         FileMultimediale(const FileMultimediale &);
         virtual void print() const;
         virtual void insert();
         virtual void memorizza_dati(const char *);
         ~FileMultimediale() {delete [] URL; delete [] Formato;}
         };
 
#endif


Implementazione delle funzioni di FileMultimediale.h:
codice:
  
#include "FileMultimediale.h"
 
FileMultimediale::FileMultimediale(const char * U, const int K, const char * F) {
                                         URL=new char[strlen(U)+1];
                                         Formato=new char[strlen(F)+1];
                                         strcpy(URL,U);
                                         strcpy(Formato,F);
                                         Kbyte=K;
                                         }
 
FileMultimediale::FileMultimediale(const FileMultimediale & F) {
                                         URL=new char[strlen(F.URL)+1];
                                         Formato=new char[strlen(F.Formato)+1];
                                         strcpy(URL,F.URL);
                                         strcpy(Formato,F.Formato);
                                         Kbyte=F.Kbyte;
                                         }
                           
//Per l'overload degli operatori di flusso, utilizzo le funzioni print() ed insert() per semplificare l'implementazione.                          
                                         
void FileMultimediale::print() const{
     cout << endl << "URL: " << URL << endl << "Dimensioni: " << Kbyte << " Kb" << endl << "Formato: " << Formato << endl << endl;
     }
     
ostream & FileMultimediale::print(ostream & os) const {
        os << endl << "URL: " << URL << endl << "Dimensioni: " << Kbyte << " Kb" << endl << "Formato: " << Formato << endl << endl;
        return os;
        }
       
ostream & operator<< (ostream & os, const FileMultimediale & F) {
        return F.print(os);
        }
       
void FileMultimediale::insert() {
     cout << "Inserisci, in ordine, URL, Dimensioni in Kbyte, e Formato: \n\n";
     cin >> URL >> Kbyte >> Formato;
     cout << endl << endl;
     }
     
istream & FileMultimediale::insert(istream & in) {
     cout << "Inserisci, in ordine, URL, Dimensioni in Kbyte, e Formato: \n\n";
     cin >> URL >> Kbyte >> Formato;
     cout << endl << endl;
     return in;
        }
       
istream & operator>> (istream & in, FileMultimediale & F) {
        return F.insert(in);
        }
 
void FileMultimediale::memorizza_dati(const char * a) {
   ofstream outfile(a, ios::out);
   cout << "______Memorizzazione dei dati su un file di testo______ \n\n";
   cout << "Scrittura ->";
   outfile << URL << " " << Kbyte << " " << Formato << endl;
   cout << "-> Operazione Completata";
   outfile.close();
}
BranoMusicale.h:
codice:
 
#ifndef _BranoMusicale_H
#define _BranoMusicale_H
 
#include "FileMultimediale.h"
 
class BranoMusicale : public FileMultimediale {
      friend ostream & operator<<(ostream &, const BranoMusicale &);
      friend istream & operator>>(istream &, BranoMusicale &);
      private:
         char * Brano;
         char * Interprete;
         float Durata;
         virtual ostream & print(ostream & os) const;
         virtual istream & insert(istream & in);
      public:
         BranoMusicale(const char * U="", const int K=0, const char * F="", const char * B="", const char * I="", const float D=0);
         BranoMusicale(const BranoMusicale &);
         virtual void print() const;
         virtual void insert();
         virtual void memorizza_dati(const char *);
         ~BranoMusicale() {delete [] Brano; delete [] Interprete;}
         };
     
#endif
Implementazione delle funzioni di BranoMusicale.h:
codice:
#include "BranoMusicale.h"
 
BranoMusicale::BranoMusicale(const char * U, const int K, const char * F, const char * B, const char * I, const float D):
FileMultimediale(U,K,F) {
                        Brano=new char[strlen(B)+1];
                        Interprete=new char[strlen(I)+1];
                        strcpy(Brano,B);
                        strcpy(Interprete,I);
                        Durata=D;
                        }
 
BranoMusicale::BranoMusicale(const BranoMusicale & B): FileMultimediale(B) {
                        Brano=new char[strlen(B.Brano)+1];
                        Interprete=new char[strlen(B.Interprete)+1];
                        strcpy(Brano,B.Brano);
                        strcpy(Interprete,B.Interprete);
                        Durata=B.Durata;
                        }
                       
void BranoMusicale::print() const{
     FileMultimediale::print();
     cout << endl << "Brano: " << Brano << endl << "Interprete: " << Interprete
     << endl << "Durata: " << Durata << endl << endl;
     }
     
ostream & BranoMusicale::print(ostream & os) const {
        FileMultimediale::print(os);
        os << endl << "Brano: " << Brano << endl << "Interprete: " << Interprete
        << endl << "Durata: " << Durata << endl << endl;
        return os;
        }
       
ostream & operator<< (ostream & os, const BranoMusicale & B) {
        return B.print(os);
        }
       
void BranoMusicale::insert() {
     FileMultimediale::insert();
     cout << "Inserisci, in ordine, Brano, Interprete e Durata: \n\n";
     cin >> Brano >> Interprete >> Durata;
     cout << endl << endl;
     }
     
istream & BranoMusicale::insert(istream & in) {
     FileMultimediale::insert(in);
     cout << "Inserisci, in ordine, Brano, Interprete e Durata: \n\n";
     cin >> Brano >> Interprete >> Durata;
     cout << endl << endl;
     return in;
        }
       
istream & operator>> (istream & in, BranoMusicale & B) {
        return B.insert(in);
        }
       
void BranoMusicale::memorizza_dati(const char * a) {
   ofstream outfile(a, ios::out);
   cout << "______Memorizzazione dei dati su un file di testo______ \n\n";
   cout << "Scrittura ->";
   outfile << URL << " " << Kbyte << " " << Formato << " "
           << Brano << " " << Interprete << " " << Durata << endl;
   cout << "-> Operazione Completata";
   outfile.close();
}
Video.h:
codice:
 
#ifndef _Video_H
#define _Video_H
 
#include "FileMultimediale.h"
 
class Video : public FileMultimediale {
      friend ostream & operator<<(ostream &, const Video &);
      friend istream & operator>>(istream &, Video &);
      private:
         char * Autore;
         char * Soggetto;
         char * Data;
         virtual ostream & print(ostream & os) const;
         virtual istream & insert(istream & in);
      public:
         Video(const char * U="", const int K=0, const char * F="", const char * A="", const char * S="", const char * D="");
         Video(const Video &);
         virtual void print() const;
         virtual void insert();
         virtual void memorizza_dati(const char *);
         ~Video() {delete [] Autore; delete [] Soggetto; delete [] Data;}
         };
 
#endif
Implementazione delle funzioni di Video.h:
codice:
#include "Video.h"
 
Video::Video(const char * U, const int K, const char * F, const char * A, const char * S, const char * D):
FileMultimediale(U,K,F) {
                        Autore=new char[strlen(A)+1];
                        Soggetto=new char[strlen(S)+1];
                        Data=new char[strlen(D)+1];
                        strcpy(Autore,A);
                        strcpy(Soggetto,S);
                        strcpy(Data,D);
                        }
 
Video::Video(const Video & V): FileMultimediale(V) {
                        Autore=new char[strlen(V.Autore)+1];
                        Soggetto=new char[strlen(V.Soggetto)+1];
                        Data=new char[strlen(V.Data)+1];
                        strcpy(Autore,V.Autore);
                        strcpy(Soggetto,V.Soggetto);
                        strcpy(Data,V.Data);
                        }
                       
void Video::print() const{
     FileMultimediale::print();
     cout << endl << "Autore: " << Autore << endl << "Soggetto: " << Soggetto
     << endl << "Data " << Data << endl << endl;
     }
     
ostream & Video::print(ostream & os) const {
        FileMultimediale::print(os);
        os << endl << "Autore: " << Autore << endl << "Soggetto: " << Soggetto
        << endl << "Data " << Data << endl << endl;
        return os;
        }
       
ostream & operator<< (ostream & os, const Video & V) {
        return V.print(os);
        }
       
void Video::insert() {
     FileMultimediale::insert();
     cout << "Inserisci, in ordine, Autore, Soggetto e Data: \n\n";
     cin >> Autore >> Soggetto >> Data;
     cout << endl << endl;
     }
     
istream & Video::insert(istream & in) {
     FileMultimediale::insert(in);
     cout << "Inserisci, in ordine, Autore, Soggetto e Data: \n\n";
     cin >> Autore >> Soggetto >> Data;
     cout << endl << endl;
     return in;
        }
       
istream & operator>> (istream & in, Video & V) {
        return V.insert(in);
        }
       
void Video::memorizza_dati(const char * a) {
   ofstream outfile(a, ios::out);
   cout << "______Memorizzazione dei dati su un file di testo______ \n\n";
   cout << "Scrittura ->";
   outfile << URL << " " << Kbyte << " " << Formato << " "
           << Autore << " " << Soggetto << " " << Data << endl;
   cout << "-> Operazione Completata";
   outfile.close();
}
CodaStatica.h:
codice:
 
#ifndef _Coda_Statica
#define _Coda_Statica
#include "BranoMusicale.h"
#include "Video.h"
 
typedef FileMultimediale F;
 
class CodaStatica{
      private:
         static const int N=10;
         F E[N];
         int t,c;
      public:
         CodaStatica();
         virtual void append(const F &);
         virtual void pop(F &);
         bool full() const;
};
 
#endif
Implementazione delle funzioni di CodaStatica.h:

codice:
  
#include "CodaStatica.h"
 
CodaStatica::CodaStatica() {
             t=0;
             c=0;
}
 
void CodaStatica::append(const F & a) {
             E[c]=a;
             c++;
             }
             
void CodaStatica::pop(F & a) {
             a=E[t];
             t++;
             }