PROBLEMA Stampa solo parte del programma

Mr.Cobra

Nuovo Utente
Questa è la traccia del mio esercizio:
Si realizzi la gerarchia Attivita (classe base), Processo (classe derivata). La classe Attivita ha le variabili menbro:

  • PID (intero),
  • Descrizione (stringa di caratteri allocata dinamicamente),
  • Started (boolean).
La classe Processo aggiunge le variabili membro:

  • NomeImmagine (stringa di caratteri allocata dinamicamente)
  • Stato (carattere). Lo stato può essere R (in esecuzione), P (Pronto), W (In attesa).
Si implementino per le classi della gerarchia le funzionalità necessarie ad una corretta gestione dell’estensione dinamica, l’overloading degli operatori >> e <<, le funzioni set e get. Si implementi per entrambe le classi la funzionalità Attiva che implementata dalla classe Attività pone a true la variabile membro Started e implementata dalla classe Processo pone a true la variabile membro Started e a R la variabile membro Stato solo se lo stato corrente è P.

Si realizzi quindi una coda di processi ricorrendo ad una implementazione mediante lista a puntatori. la cui funzione di inserimento effettua un normale inserimento in coda FIFO, mentre la funzione di estrazione elimina dalla coda il primo dei processi pronti. Si gestiscano ovviamente i casi coda piena, coda vuota e assenza di processi pronti. La funzione di inserimento lancia una eccezione (classe definita dallo studente) nel caso si tenti di inserire in coda un PID già presente. Si implementino inoltre le funzionalità

  • GetP che restituisce il numero dei processi pronti presenti nella coda,
  • Schedule che fornito in ingresso un PID consente di attivare il processo corrispondente (se possibile) e comporta la rimozione immediata dalla coda
  • Store che stampa a video l’elenco dei processi in coda
  • Show che stampa tale elenco su file di tipo testo.


Si realizzi un programma di test che consenta all’utente di operare sulla coda attraverso un menù, consentendo le operazioni di inserimento, attivazione, rimozione, show e stampa.

Questo è il mio programma:

Attivitalib.h
C++:
#ifndef ATTIVITALIB_H
#define ATTIVITALIB_H

#include <iomanip>
#include <iostream>
#include <cstdlib>
#include <cstring>

#define DIM 100

using namespace std;

namespace Programma{
  
    typedef char Buffer [DIM];
  
    class Attivita{
      
        friend ostream &operator<<(ostream &, const Attivita &);
        friend istream &operator>>(istream &, Attivita &);
      
        private:
            int PID;
            char *Descrizione;
            bool Started;
          
        protected:
            virtual ostream &stampa(ostream &)const;
            virtual istream &leggi(istream &);

        public:
            Attivita(const int =0, const char * ="", const bool =false);
            Attivita(const Attivita &);
            ~Attivita(){ delete [] Descrizione; };
          
            void set_Attivita(const Attivita &);
            void set_PID(const int P){ PID=P;};
            void set_Descrizione(const char *);
            void set_Started(const bool SD){ Started=SD; };
          
            const int get_PID(){ return PID;};
            const char *get_Descrizione(){ return Descrizione;};
            const bool get_Started(){ return Started;};

            const Attivita &operator=(const Attivita &);
            bool operator==(const Attivita &)const;
            bool operator!=(const Attivita &)const;
          
            virtual void Attiva();

    };
  
}

#endif
Attivitafun.cpp

C++:
#include "Attivitalib.h"

namespace Programma{
  
    Attivita::Attivita(const int P, const char *D, const bool SD):PID(P), Descrizione(new char [strlen(D)+1]),Started(SD){
        strcpy(Descrizione,D);
    }
    Attivita::Attivita(const Attivita &A):PID(A.PID), Descrizione(new char [strlen(A.Descrizione)+1]),Started(A.Started){
        strcpy(Descrizione,A.Descrizione);
    }
  
    void Attivita::set_Attivita(const Attivita &A){
        set_PID(A.PID);
        set_Descrizione(A.Descrizione);
        set_Started(A.Started);
    }
  
    void Attivita::set_Descrizione(const char *D){
        if(Descrizione) delete [] Descrizione;
        Descrizione= new char [strlen(D)+1];
        strcpy(Descrizione,D);
    }
    const Attivita &Attivita::operator=(const Attivita &A){
        if(&A!=this)set_Attivita(A);
    }
  
    bool Attivita::operator==(const Attivita &A)const{
        return(PID==A.PID && !strcmp(Descrizione, A.Descrizione) && Started==A.Started);
    }
    bool Attivita::operator!=(const Attivita &A)const{
        return(!this->operator==(A));
    } 
    ostream &operator<<(ostream &out, const Attivita &A){
        return A.stampa(out);
    }
  
    istream &operator>>(istream &in, Attivita &A){
        return A.leggi(in);
    }
      

    ostream &Attivita::stampa(ostream &out)const{
        out<<"\n |PID: "<<PID<<"|Descrizione: "<<Descrizione<<"|Started: "<<Started<<endl;
        return out;
    }
  
    istream &Attivita::leggi(istream &in){
        Buffer b;
        cout<<"\n Insersici il PID: ";
        in>>PID;
        in.ignore();
        cout<<"\n Insersici la Descrizione: ";
        in.getline(b, DIM-1, '\n');
        set_Descrizione(b);
        in.ignore();
        cout<<"\n Insersici lo Started: ";
        in>>Started;
        in.ignore();
        return in;
    }
  
    void Attivita::Attiva(){
        Started=true;
    }

  
}
Processolib.h

C++:
#ifndef PROCESSOLIB_H
#define PROCESSOLIB_H

#include "Attivitalib.h"

namespace Programma{
  
    class Processo: public Attivita{
      
        friend ostream &operator<<(ostream &, const Processo &);
        friend istream &operator>>(istream &, Processo &);
      
        private:
            char *NomeImmagine;
            char Stato;
          
        protected:
            virtual ostream &stampa(ostream &)const;
            virtual istream &leggi(istream &);
          

        public:
            Processo(const int =0, const char * ="",const bool =false, const char * ="", char ='W');
            Processo(const Processo &);
            ~Processo(){ delete [] NomeImmagine; };
          
            void set_Processo(const Processo &);
            void set_NomeImmagine(const char *);
            void set_Stato(const bool SO){ Stato=SO; };
            ;
            const char *get_NomeImmagine(){ return NomeImmagine;};
            const char get_Stato(){ return Stato;};

            const Processo &operator=(const Processo &);
            bool operator==(const Processo &)const;
            bool operator!=(const Processo &)const;
          
            virtual void Attiva();
          
    };
  
}

#endif

Processofun.cpp

C++:
#include "Processolib.h"

namespace Programma{
  
    Processo::Processo(const int P, const char *D,const bool SD, const char *N, char SO):Attivita(P, D, SD), NomeImmagine(new char [strlen(N)+1]), Stato(SO){
        strcpy(NomeImmagine,N);
    }
    Processo::Processo(const Processo &P):Attivita(P), NomeImmagine(new char [strlen(P.NomeImmagine)+1]), Stato(P.Stato){
        strcpy(NomeImmagine,P.NomeImmagine);
    }
  
    void Processo::set_Processo(const Processo &P){
        set_Attivita(P);
        set_NomeImmagine(P.NomeImmagine);
        set_Stato(P.Stato);
    }
  
    void Processo::set_NomeImmagine(const char *N){
        if(NomeImmagine) delete [] NomeImmagine;
        NomeImmagine= new char [strlen(N)+1];
        strcpy(NomeImmagine,N);
    }
    const Processo &Processo::operator=(const Processo &P){
        if(&P!=this)set_Processo(P);
    }
  
    bool Processo::operator==(const Processo &P)const{
        return(Attivita::operator==(P) && !strcmp(NomeImmagine, P.NomeImmagine) && Stato==P.Stato);
    }
    bool Processo::operator!=(const Processo &P)const{
        return(!this->operator==(P));
    } 
    ostream &operator<<(ostream &out, const Processo &P){
        return P.stampa(out);
    }
  
    istream &operator>>(istream &in, Processo &P){
        return P.leggi(in);
    }
      

    ostream &Processo::stampa(ostream &out)const{
        Attivita::stampa(out);
        out<<"\n |Nome immagine: "<<NomeImmagine<<"|Stato: "<<Stato<<endl;
        return out;
    }
  
    istream &Processo::leggi(istream &in){
        Buffer b;
        Attivita::leggi(in);     
        cout<<"\n Insersici il Nome immagine: ";
        in.getline(b, DIM-1, '\n');
        set_NomeImmagine(b);
        in.ignore();
        cout<<"\n Insersici lo Stato: ";
        in>>Stato;
        in.ignore();
        return in;
    }

    void Processo::Attiva(){
        Attivita::Attiva();
        if(Stato=='P'){
            Stato='R';
        }
    }
}
Listalib.h

C++:
#ifndef LISTALIB_H
#define LISTALIB_H

#include "Processolib.h"
#include "Errorelib.h"
#include <string>
#include <fstream>

namespace Programma{
  

    class Nodo;
    typedef Processo T;
      
    class Lista{
          
        private:
            class Nodo{
                friend class Lista;
                Nodo * Next;
                T Elem;
            };
            Nodo *Testa;
            Nodo *Coda;
            void clear();


        public:
            Lista();
            ~Lista(){ void clear(); };
          
            bool inLista(const T &);
            bool Inserisci(const T &)throw(Errore);
            bool Elimina(const T &)throw(Errore);;
            bool EliminaPronti()throw(Errore);
            bool Empty()const {return Testa==0;};
            bool Full()const {return false;};

            bool Absent()const;
            const int get_Ready()const;
            void Scheulde(const int );
            void Store()const;
            void Show(const char * )const throw(Errore);
          
    };
  
}

#endif
Listafun.cpp

C++:
#include "Listalib.h"

namespace Programma{
  
    Lista::Lista(){ Testa=0; Coda=0; };
          
    void Lista::clear(){
        Nodo *Temp=Testa;
        while(Testa){
            Testa=Testa->Next;
            delete Temp;
            Temp=Testa;
        }
    }

    bool Lista::inLista(const T &E){
        if(Empty()) return false;
        bool trovato=false;
        Nodo *Temp=Testa;
        while(Temp && !trovato){
            if(Temp->Elem==E){
            trovato=true;
            }
            Temp=Temp->Next;
        }
        return trovato;
    }
  
    bool Lista::Inserisci(const T &E)throw(Errore){
        if(inLista(E)){
            throw Errore("Elemento già presente nella lista! \n");
        }
        Nodo *NE;
        NE=new Nodo;
        NE->Elem=E;
        if(Empty()){
            Testa=NE;
            Coda=NE;
        }else{
            NE->Next=0;
            Coda->Next=NE;
        }
        return true;
      
    }
  
    bool Lista::Elimina(const T &E)throw(Errore){
        if(!inLista(E)){
            throw Errore("Elemento non presente in lista! \n");
        }
        Nodo *Temp=Testa;
        while(Temp->Next->Elem==E)Temp=Temp->Next;
            Nodo *N=Temp->Next;
            Temp->Next=Temp->Next->Next;
            delete N;
            return true;
    }
          
    bool Lista::EliminaPronti()throw(Errore){
        if(Empty()){
            throw Errore("La lista  è vuota! \n");
        }
        Nodo *Temp=Testa;
        while(Temp->Next->Elem.get_Stato()!='P') Temp=Temp->Next;
            Nodo *N=Temp->Next;
            Temp->Next=Temp->Next->Next;
            delete N;
            return true;
    }
  
    const int Lista::get_Ready()const{
        if(Empty()) return 0;
        Nodo *Temp=Testa;
        int count=0;
        while(Temp){
            if(Temp->Elem.get_Stato()!='P'){ count++; }
            Temp=Temp->Next;
        }
        return count;
    }
  
    void Lista::Scheulde(const int PID){
        Nodo *Temp=Testa;
        while(Testa){
            if(Temp->Elem.get_PID()==PID){
                Temp->Elem.Attiva();
                Elimina(Temp->Elem);
            }
        }
    }
  
    void Lista::Store()const{
        Nodo *Temp=Testa;
        while(Temp){
            cout<<Temp->Elem<<endl;
            Temp=Temp->Next;
        }
    }
    void Lista::Show(const char *Nome)const throw(Errore){
        fstream File;
        File.open(Nome);
        if(!File){
            throw Errore("\n Errore durante il caricamento del file! ");
        }
        Nodo *Temp=Testa;
            while(Temp){
                File<<Temp->Elem<<endl;
                Temp=Temp->Next;
            }
    }
          

  
}
Errorelib.h

C++:
#ifndef ERRORELIB_H
#define ERRORELIB_H

#include <string>

using namespace std;

namespace Programma{
  
    class Errore{
        private:
            string Error;
          
        public:
            Errore(string E):Error(E){ };
            const string what()const;
          
    }; 
}


#endif

Errorefun.cpp

C++:
#include "Errorelib.h"

namespace Programma{
  
    const string Errore::what()const{
        string msg;
        msg="\n Errore! "+Error;
        return msg.c_str();
  
    }
  
}
main.cpp

C++:
#include <iostream>
#include <fstream>

#include "Listalib.h"
#include "Processolib.h"
#include "Attivitalib.h"


using namespace Programma;
using namespace std;

int main(int argc, char** argv) {
  
    fstream File;
    Attivita A1(12235, "Intro", false);
    Processo P1(122665, "Scansione",false, "VIRUS", 'P');
    Attivita A2(12238, "Risulati", false);
    Processo P2(122665, "Quarantena",false, "Malware", 'R');
    Attivita A3(12237, "Chiusura", false);
    Processo P3(122665, "Salvataggio",false, "Minacce", 'P');
  
    cout<<A1<<P1<<A2<<endl;
    cout<<A3<<P2<<A3<<endl;
  
    Lista L1;
  
    L1.Inserisci(P1);
    L1.Inserisci(P2);
    L1.Inserisci(P3);

    cout<<"-----------------------"<<endl<<endl;

    L1.Store();
  
    cout<<"-----------------------"<<endl<<endl;
    L1.Store();
    L1.Show("Antivirus.txt");
  
    cout<<"Gli elementi in coda sono: "<<L1.get_Ready()<<endl;
    L1.EliminaPronti();
    cout<<"Gli elementi nella coda sono"<<L1.get_Ready()<<endl;
  
    L1.Store();
    L1.Scheulde(122665);
    cout<<"Gli elementi nella coda sono"<<L1.get_Ready()<<endl;
  
  
}
Immagine2.png
 

Entra

oppure Accedi utilizzando