RISOLTO [C++] Programma che stampa saltando istruzioni

[Mr.Cobra]

Salve il mio programma stampa da un punto e non riesco a capire perchè salti le istruzioni precedenti il mio programma testa tessere elettroniche e stabilisce tramite la funzione virtual check():
- se l'oggetto della classe Carta abbia il giusto Numero di carta composto da 8 caratteri e che le prime 5 siano cifre numeriche;
- se l'oggetto della classe Bancomat controlla che la stringa fornita in ingresso corrisponda al PIN della carta nel caso la carta sia attivata. Ovviamente restituisce falso se la carta non è attivata o se il PIN non è valido.
-se se l'oggetto della classe T_Sanitaria controlla che la stringa fornita in ingresso corrisponda al codice fiscale.
E poi c'è una funzione Attiva che invocata su un oggetto attiva la carta ponendo la relativa variabile membro a true e assegnando a PIN una stringa di cifre che per semplicità supponiamo essere costituita dalle prime 5 cifre del numero di carta più un offset casuale ottenuto utilizzando la funzione rand. Non deve essere possibile settare il PIN mediante un costruttore.

Questo è il mio programma:

Spoiler

Datalib.h

#ifndef DATALIB_H
#define DATALIB_H

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

#define DIM 100

using namespace std;

namespace Tessera{
   
   
    class Data{
       
        friend ostream &operator<<(ostream &, const Data &);
        friend istream &operator>>(istream &, Data &);
       
        private:
            int Giorno;
            int Mese;
            int Anno;
           
        protected:
            virtual ostream &stampa(ostream &)const;
            virtual istream &leggi(istream &);
           
        public:
            Data(const int G=0, const int M=0, const int A=0):Giorno(G), Mese(M), Anno(A) {};
            Data(const Data &D):Giorno(D.Giorno), Mese(D.Mese), Anno(D.Anno) {};
           
            void set_Data(const Data &D){ set_Giorno(D.Giorno); set_Mese(D.Mese); set_Anno(D.Anno); };
            void set_Giorno(const int G){ Giorno=G; };
            void set_Mese(const int M){ Mese=M; };
            void set_Anno(const int A){ Anno=A; };
           
            const int get_Giorno(){ return Giorno; };
            const int get_Mese(){ return Mese; };
            const int get_Anno(){ return Anno; };
           
            const Data &operator=(const Data &);
            bool operator==(const Data &)const;
            bool operator!=(const Data &)const;
       
    };
   
}

#endif

Datafun.cpp

#include "Datalib.h"

namespace Tessera{
   
    const Data &Data::operator=(const Data &D){
        if(&D!=this){ set_Data(D); }
    }
   
    bool Data::operator==(const Data &D)const{
        return (Giorno==D.Giorno && Mese==D.Mese && Anno==D.Anno);
    }
   
    bool Data::operator!=(const Data &D)const{
        return(!this->operator==(D));
    }
   
    ostream &operator<<(ostream &out, const Data &D){
        return D.stampa(out);
    }
   
    istream &operator>>(istream &in, Data &D){
        return D.leggi(in);
    }
   
    ostream &Data::stampa(ostream &out)const{
        out<<"| Giorno: "<<Giorno<<"| Mese"<<Mese<<"| Anno: "<<Anno;
        return out;
    }
   
    istream &Data::leggi(istream &in){
        cout<<"Inserisci il giorno: \n";
        in>>Giorno;
        cout<<"Inserisci il mese: \n";
        in>>Mese;
        cout<<"Inserisci l'anno: \n";
        in>>Anno;
        return in;
    }
   
}

Cartalib.h

#ifndef CARTALIB_H
#define CARTALIB_H

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

#include "Errorelib.h"

#define DIM 100

using namespace std;

namespace Tessera{
   
    typedef char Buffer [DIM];
   
    class Carta{
       
        friend ostream &operator<<(ostream &, const Carta &);
       
        private:
            char *Tipo;
            char *Intestatario;
            char *Numerocarta;
            bool Controllo(const char *)const;
           
        protected:
            virtual ostream &stampa(ostream &)const;

           
           
        public:
            Carta(const char * ="", const char * ="", const char * ="");
            Carta(const Carta &);
            ~Carta(){ delete [] Tipo; delete [] Intestatario; delete [] Numerocarta;};
           
            void set_Carta(const Carta &);
            void set_Tipo(const char *);
            void set_Intestatario(const char *);
            void set_Numerocarta(const char *);
           
            const char *get_Tipo(){ return Tipo; };
            const char *get_Intestario(){ return Intestatario; };
            const char *get_Numerocarta(){ return Numerocarta; };
           
            const Carta &operator=(const Carta &);
            bool operator==(const Carta &)const;
            bool operator!=(const Carta &)const;
           
            virtual bool Check(const char *)const;
       
    };
   
}

#endif

Caratafun.cpp

#include "Cartalib.h"

namespace Tessera{
   
    Carta::Carta(const char *T, const char *I, const char *N):Tipo(new char [strlen(T)+1]), Intestatario(new char [strlen(I)+1]), Numerocarta(new char [strlen(N)+1]){
        strcpy(Tipo, T);
        strcpy(Intestatario, I);
        strcpy(Numerocarta, N);
    }
   
    Carta::Carta(const Carta &C):Tipo(new char [strlen(C.Tipo)+1]), Intestatario(new char [strlen(C.Intestatario)+1]), Numerocarta(new char [strlen(C.Numerocarta)+1]){
        strcpy(Tipo, C.Tipo);
        strcpy(Intestatario, C.Intestatario);
        strcpy(Numerocarta, C.Numerocarta);
    }
   
    void Carta::set_Carta(const Carta &C){
        set_Tipo(C.Tipo);
        set_Intestatario(C.Intestatario);
        set_Numerocarta(C.Numerocarta);
    }
               
               
    void Carta::set_Tipo(const char *T){
        if(Tipo) delete [] Tipo;
        Tipo=new char[strlen(T)+1];
        strcpy(Tipo,T);
    }
   
    void Carta::set_Intestatario(const char *I){
        if(Intestatario) delete [] Intestatario;
        Intestatario=new char[strlen(I)+1];
        strcpy(Intestatario,I);
    }
   
    void Carta::set_Numerocarta(const char *N){
        if(Numerocarta) delete [] Numerocarta;
        Numerocarta=new char[strlen(N)+1];
        strcpy(Numerocarta,N);
    }
   
    const Carta &Carta::operator=(const Carta &C){
        if(&C!=this){
            if(Tipo) delete [] Tipo;
            if(Intestatario) delete [] Intestatario;
            if(Numerocarta) delete [] Numerocarta;
            set_Carta(C);
        }
    }
   
    bool Carta::operator==(const Carta &C)const{
        return (!strcmp(Tipo, C.Tipo) && !strcmp(Intestatario, C.Intestatario) && !strcmp(Numerocarta, C.Numerocarta));
    }
   
    bool Carta::operator!=(const Carta &C)const{
        return(!this->operator==(C));
    }
   
    ostream &operator<<(ostream &out, const Carta &C){
        return C.stampa(out);
    }
   
    ostream &Carta::stampa(ostream &out)const{
        out<<"| Tipo: "<<Tipo<<"| Intestario"<<Intestatario<<"| Numero carta: "<<Numerocarta;
        return out;
    }
   
    bool Carta::Check(const char *N)const{
        if(Controllo(N)){
            throw("\n Numero di carta non valido");
            return false;
        }else return true;
    }
   
    bool Carta::Controllo(const char *N)const{
        int dim=0;
        char min='0';
        char max='9';
        dim=strlen(N);
        if(dim>8){
            int cont=0;
            for(int i=0; i<5; i++){
                if(N[i]>=min && N[i]<=max){
                    cont++;
                }
            }
            if(cont==5){
                return true;
            }else return false;  
        }else return false;
    }
}

Bancomatlib.h

#ifndef BANCOMATLIB_H
#define BANCOMATLIB_H

#include "Cartalib.h"
#include "Datalib.h"
namespace Tessera{
   
    class Bancomat: public Carta{
       
        friend ostream &operator<<(ostream &, const Bancomat &);
       
        private:
            char *PIN;
            bool Attiva;
            Data Datascadenza;
            void set_Bancomat(const Bancomat &);
            void set_PIN(const char *);
            void set_Attiva(const bool A){ Attiva=A; };

        protected:
            virtual ostream &stampa(ostream &)const;
           
           
           
        public:
            Bancomat(const char *T="", const char *I="", const char *N="", const int G=0, const int M=0, const int A=0) : Carta(T, I, N), Datascadenza(G, M, A) { };
            Bancomat(const Bancomat &B): Carta(B), Datascadenza(B.Datascadenza) {  };
            ~Bancomat(){ delete [] PIN; };
           
            const char *get_PIN(){ return PIN; };
            bool get_Attiva(){ return Attiva; };
            Data get_Datascadenza(){ return Datascadenza; };
           
            const Bancomat &operator=(const Bancomat &);
            bool operator==(const Bancomat &)const;
            bool operator!=(const Bancomat &)const;
           
            virtual bool Check(const char *)const;
            void attiva();
       
    };
   
}

#endif

Bancomatfun.cpp

#include "Bancomatlib.h"

namespace Tessera{          
   
    void Bancomat::set_Bancomat(const Bancomat &B){
        set_PIN(B.PIN);
        set_Attiva(B.Attiva);
        Datascadenza.set_Data(B.Datascadenza);
    }
               
    void Bancomat::set_PIN(const char *P){
        if(PIN) delete [] PIN;
        PIN=new char[strlen(P)+1];
        strcpy(PIN,P);
    }
   
   
    const Bancomat &Bancomat::operator=(const Bancomat &B){
        if(&B!=this){
            if(PIN) delete [] PIN;
            set_Bancomat(B);
        }
    }
   
    bool Bancomat::operator==(const Bancomat &B)const{
        return (Carta::operator==(B) && Datascadenza.operator==(B.Datascadenza) && !strcmp(PIN, B.PIN) && Attiva==B.Attiva );
    }
   
    bool Bancomat::operator!=(const Bancomat &B)const{
        return(!this->operator==(B));
    }
   
    ostream &operator<<(ostream &out, const Bancomat &B){
        return B.stampa(out);
    }
   
    ostream &Bancomat::stampa(ostream &out)const{
        Carta::stampa(out);
        out<<"| PIN: "<<PIN<<"| Stato: "<<(Attiva==true ? "Attiva":"Disattiva")<<"| Data di scadenza: "<<Datascadenza;
        return out;
    }
   
    void Bancomat::attiva(){
        char buffer[11];
        set_Attiva(true);
        for(int i=0; i<5; i++){
            buffer[i]=get_Numerocarta()[i];
        }
        for(int i=6; i<10; i++){
            buffer[i]= 48+rand() % 10;
        }
        set_PIN(buffer);
    }
   
    bool Bancomat::Check(const char *P)const{
        if(Attiva==true){
            if(strcmp(PIN, P)){
            throw("PIN non valido!");
            return false ;
            }else return true;
        }else return true;
    }
   
}

Codicefislib.cpp

#ifndef CODICEFISLIB_H
#define CODICEFISLIB_H

#include "Cartalib.h"
#include "Datalib.h"

namespace Tessera{
   
    class T_Sanitaria: public Carta{
       
        friend ostream &operator<<(ostream &, const T_Sanitaria &);
       
        private:
            char *Codicefiscale;
            Data Datarilascio;
            Data Datascadenza;
           
        protected:
            virtual ostream &stampa(ostream &)const;
       
           
        public:
            T_Sanitaria(const char * ="", const char * ="", const char * ="",const char * ="",
             const int =0, const int =0, const int =0, const int =0, const int =0, const int =0);
            T_Sanitaria(const T_Sanitaria &);
            ~T_Sanitaria(){ delete [] Codicefiscale; };
           
            void set_T_Sanitaria(const T_Sanitaria &);
            void set_Codicefiscale(const char *);
           
            const char *get_Codicefiscale(){ return Codicefiscale; };
           
            const T_Sanitaria &operator=(const T_Sanitaria &);
            bool operator==(const T_Sanitaria &)const;
            bool operator!=(const T_Sanitaria &)const;
           
            virtual bool Check(const char *)const;
           
    };
   
}

#endif

Codicefisfun.cpp

#include "Codicefislib.h"

namespace Tessera{
   
    T_Sanitaria::T_Sanitaria(const char *T, const char *I, const char *N,const char *CF,
     const int G_R, const int M_R, const int A_R, const int G_S, const int M_S, const int A_S)
     :Carta(T, I, N), Codicefiscale(new char [strlen(CF)+1]), Datarilascio(G_R, M_R, A_R), Datascadenza(G_S, M_S, A_S){
        strcpy(Codicefiscale, CF);
    }
   
    T_Sanitaria::T_Sanitaria(const T_Sanitaria &TS):Carta(TS), Codicefiscale(new char [strlen(TS.Codicefiscale)+1]),
     Datarilascio(TS.Datarilascio), Datascadenza(TS.Datascadenza){
        strcpy(Codicefiscale, TS.Codicefiscale);
    }
   
    void T_Sanitaria::set_T_Sanitaria(const T_Sanitaria &TS){
        set_Codicefiscale(TS.Codicefiscale);
        Datarilascio.set_Data(TS.Datarilascio);
        Datascadenza.set_Data(TS.Datascadenza);
    }
               
               
    void T_Sanitaria::set_Codicefiscale(const char *CF){
        if(Codicefiscale) delete [] Codicefiscale;
        Codicefiscale=new char[strlen(CF)+1];
        strcpy(Codicefiscale,CF);
    }
   
    const T_Sanitaria &T_Sanitaria::operator=(const T_Sanitaria &TS){
        if(&TS!=this){
            if(Codicefiscale) delete [] Codicefiscale;
            set_T_Sanitaria(TS);
        }
    }
   
    bool T_Sanitaria::operator==(const T_Sanitaria &TS)const{
        return (Carta::operator==(TS) && Datascadenza.operator==(TS.Datascadenza) && !strcmp(Codicefiscale, TS.Codicefiscale) && Datarilascio.operator==(TS.Datarilascio) );
    }
   
    bool T_Sanitaria::operator!=(const T_Sanitaria &TS)const{
        return(!this->operator==(TS));
    }
   
    ostream &operator<<(ostream &out, const T_Sanitaria &TS){
        return TS.stampa(out);
    }
   
    ostream &T_Sanitaria::stampa(ostream &out)const{
        Carta::stampa(out);
        out<<"| Codice fiscale: "<<Codicefiscale<<"| Data di rilascio"<<Datarilascio<<"| Data di scadenza: "<<Datascadenza;
        return out;
    }
   
    bool  T_Sanitaria::Check(const char *CF)const{
        if(strcmp(Codicefiscale, CF)){
            throw("Codice fiscale non valido!");
            return false ;
        }else return true;
    }
   
}

Errorelib.cpp

#ifndef ERRORELIB_H
#define ERRORELIB_H

#include <string>

using namespace std;

namespace Tessera{
   
    class Errore{
   
        private:
            string error;
   
        public:
            Errore(string E) :error(E){};
            const char *what()const;
   
    };

}

#endif

Errorefun.cpp

#include "Errorelib.h"

namespace Tessera{
   
    const char *Errore::what()const{
        string msg;
        msg= "\n Errore durante l'inserimeto! " +error;
        return msg.c_str();
    }
   
}

main.cpp

#include <iostream>

#include "Cartalib.h"
#include "Codicefislib.h"
#include "Bancomatlib.h"
#include "Datalib.h"

using namespace std;
using namespace Tessera;

int main(int argc, char** argv) {
   
    Bancomat a("Bancomat","Luca","123456abcde",48,11,2020);
    Bancomat b("Bancomat","Mario","12789fewae",20,1,2020);
    Bancomat c("Bancomat","Carlo","1246abce",27,16,2020);
   
    cout<<a<<endl<<b<<endl<<c<<endl;
   
    a.attiva();
    b.attiva();
    c.attiva();
   
    cout<<endl;
    cout<<a<<endl<<b<<endl<<c<<endl; //in poche parole mi stampa da qua perchè?
   
    T_Sanitaria d("Tessera","Luca","789456123654","MSNNRL97S27I234Q",12,456,77,489,5,2589);
   
    Carta *Vett[4];
   
    Vett[0]=&a;
    Vett[1]=&b;
    Vett[2]=&c;
    Vett[3]=&d;
   
    for(int i=0; i<4; i++){
        try{
            if(Vett[i]->Check(Vett[i]->get_Numerocarta())){
                cout<<"\n Gli elementi che superano il test sono: "<<*Vett[i];
            }
        }catch(Errore E){
            cout<<E.what()<<endl;
        }
    }
   
   
   
    return 0;
}

 

[Andretti60]

Use the debugger, Luke [cit.]

 

[Mr.Cobra]

Use the debugger, Luke [cit.]

Noooooooooo Cit Luke
Non lo posso usare all'esame, mai usato, comunque vorrei impararlo ad usare puoi passarmi guide o link ecc...? Uso solo compila ed esegui, non mi da nessun errore il compilatore, conosci qualche trucco jedi o via oscura sith che mi può essere d'aiuto?

 

[Andretti60]

Nessun trucco. Usiamo la Sorgente, non la Forza :)
Metti un breakpoint nel main() nella prima istruzione, e quando il programma si arresta vai avanti una istruzione per volta, guardando cosa fa l'istruzione e come le variabili vengono cambiate. Non posso darti dettagli perche' non so che compilatore/debugger usi, ma quelle sono le operazioni basi che sono comuni in tutti i debugger.
Coraggio giovane padawan...

 

[_Achille]

Noooooooooo Cit Luke
Non lo posso usare all'esame, mai usato, comunque vorrei impararlo ad usare puoi passarmi guide o link ecc...? Uso solo compila ed esegui, non mi da nessun errore il compilatore, conosci qualche trucco jedi o via oscura sith che mi può essere d'aiuto?

Scusami, sono io troppo giovane, ma all’Università ti fanno usare qualcosa? Perché non capisco il senso che tu non possa usare (e abbia) un debugger...

 

[Mr.Cobra]

Nessun trucco. Usiamo la Sorgente, non la Forza :)
Metti un breakpoint nel main() nella prima istruzione, e quando il programma si arresta vai avanti una istruzione per volta, guardando cosa fa l'istruzione e come le variabili vengono cambiate. Non posso darti dettagli perche' non so che compilatore/debugger usi, ma quelle sono le operazioni basi che sono comuni in tutti i debugger.
Coraggio giovane padawan...

Uso dev c++ non ho mai usato un breakpoint cos'è? A che serve? Come si dichiara? Comunque solo un sith é riuscito a usare la forza per creare la vita W il lato oscuro!

Scusami, sono io troppo giovane, ma all’Università ti fanno usare qualcosa? Perché non capisco il senso che tu non possa usare (e abbia) un debugger...

Secondo me é una questione di tempo hanno poco tempo e preferiscono fare bene il giusto e poi approfondire certe cose alla magistrale

 

[DispatchCode]

DEV C++ non l'ho mai usato e non è il massimo. Comunque dovresti trovare "tutte" le info già dall'interfaccia grafica, o cercando su google.
Ed esempio:

- http://eilat.sci.brooklyn.cuny.edu/cis1_5/HowToDebug.htm
- https://sites.google.com/site/sirhans/Home/oop-2008/links/how-to-debug-in-dev-c

Comunque se uppi il binario (x86 o x64, dipende che target hai) provo a darti qualche indizio usando un debugger Jedi.


PS. spero che alla magistrale tratteranno ben altro... nel dubbio inizia ad approfondire tu qualcosa, ad esempio l'uso del debugger, che è fondamentale (in qualsiasi linguaggio questo).