Coda Statica di Classi Polimorfe

________________________FileMultimediale.h________________________
#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______________________

#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____________________________________
#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__________________________
#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_______________________________
#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____________________________
#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________________________________
#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__________________________

#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++;
             }