DOMANDA Una funzione funziona in due classi ma non in altre perchè?

Mr.Cobra · 12 Dicembre 2018

ToText deve unire le stringhe degli oggetti Veicolo, Automobile e/o Motocicletta in un unica stringa e immetterla in un file di testo .txt ma mi da errori che non capisco mi dai una mano? In Motocicletta e in Automobile non mi da problemi e mi fa usare Veicolo::Totext(), mentre quando inserisco Totext di motociletta o automobile in garage mi da errore perchè?

Veicolo libreria

C++:

#ifndef VEICOLILIB_H
#define VEICOLILIB_H

#include <cstdlib>
#include <iostream>
#include <fstream>
#include <cstring>

#define N_MAX 100

using namespace std;

namespace Myprog{

    typedef char buffer [N_MAX];

    class Veicolo{

        friend ostream &operator<<(ostream &,const Veicolo &);
        friend istream &operator>>(istream &, Veicolo &);
    
        protected:
            char * Nometipo;
            char * Marca;

            virtual ostream & stampa(ostream &)const;
            virtual istream & leggi(istream &);
    
        public:
            Veicolo(const char * = "", const char * = "");
            Veicolo(Veicolo &);
            ~Veicolo();
        
            void set_Veicolo(const char *,const char *);
            void set_Nometipo(const char *);
            void set_Marca(const char *);
        
            const char* get_Nometipo(){ return Nometipo; };
            const char* get_Marca(){ return Marca;};
        
            const Veicolo &operator=(const Veicolo &);
            bool operator==(const Veicolo &)const;
            bool operator!=(const Veicolo &)const;
        
            const char* accoda(const char *, const char *);
            void supporto_accoda(char *, const char *);
            virtual    const char* Totext();
    };
}
#endif

Veicoli funzioni:

C++:

#include "Veicolilib.h"

namespace Myprog{

    Veicolo::Veicolo(const char *N, const char *M){ set_Veicolo(N, M); };
    Veicolo::Veicolo(Veicolo &V){ set_Veicolo(V.Nometipo, V.Marca); };

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

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

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


    const Veicolo& Veicolo::operator=(const Veicolo &V){
        if(&V !=this){
            if(Nometipo) delete [] Nometipo;
            if(Marca) delete [] Marca;
            set_Veicolo(V.Nometipo, V.Marca);
        }
    }

    bool Veicolo::operator==(const Veicolo &V)const{
        return(!strcmp(Nometipo, V.Nometipo) && !strcmp(Marca,V.Marca));
    }

    bool Veicolo::operator!=(const Veicolo &V)const{
        return(! this -> operator==(V));
    }

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

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

    ostream & Veicolo::stampa(ostream &out)const{
        out<<"|Nome tipo: "<<Nometipo<<"| Marca: "<<Marca;
        return out;
    }

    istream & Veicolo::leggi(istream &in){
        buffer b1, b2;
        in.getline(b1, N_MAX-1, '\n');
        set_Nometipo(b1);
        in.ignore();
        in.getline(b2, N_MAX-1, '\n');
        set_Marca(b2);
        in.ignore();
        return in;
    
    }

    const char* Veicolo::accoda(const char *N, const char *M){
        char *s1;
        char *s2;
        char *s3;
        supporto_accoda(s1,N);
        supporto_accoda(s2,M);
        s3=new char [strlen(s1)+strlen(s2)+2];
        strcpy(s3,s1);
        strcat(s3,s2);
        return s3;
    }

    void Veicolo::supporto_accoda(char *s, const char *V){
        char spazio[]=" ";
        s=new char[strlen(V)+2];
        strcpy(s, V);
        strcat(s, spazio);
    }

    const char * Veicolo::Totext(){
        char *StringaV;
        StringaV=new char [strlen(accoda(Nometipo,Marca))+1];
        strcpy(StringaV,accoda(Nometipo,Marca));
        return StringaV;
    }

}

Motocicletta libreria

C++:

#ifndef MOTOLIB_H

#define MOTOLIB_H



#include "Veicolilib.h"



namespace Myprog{



    class Motocicletta: public Veicolo{

   

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

        friend istream &operator>>(istream &, Motocicletta &);

   

        private:

            char *Tipo;

   

        protected:

            virtual ostream & stampa(ostream &)const;

            virtual istream & leggi(istream &);



   

        public:

            Motocicletta(const char * = "", const char * ="", const char * ="");

            Motocicletta(const Motocicletta &);

            ~Motocicletta() { delete [] Tipo; };

       

            void set_Tipo(const char *);

       

            const char * get_Tipo(){ return Tipo; };

       

            const Motocicletta &operator=(const Motocicletta &);

            bool operator==(const Motocicletta &)const;

            bool operator!=(const Motocicletta &)const;

       

            virtual const char * Totext();

       

    };



}



#endif

Motocicletta funzioni:

C++:

#include "Motolib.h"

namespace Myprog{

    Motocicletta::Motocicletta(const char *N, const char *M, const char *T):Veicolo(N,M) { set_Tipo(T); };
    Motocicletta::Motocicletta(const Motocicletta & Mo) :Veicolo(Mo.Nometipo, Mo.Marca){ set_Tipo(Mo.Tipo); };

    void Motocicletta::set_Tipo(const char *T){
        Tipo=new char [strlen(T)+1];
        strcpy(Tipo, T);
    }

    const Motocicletta & Motocicletta::operator=(const Motocicletta &Mo){
        if(&Mo !=this){
            Veicolo::operator=(Mo);
            if(Tipo) delete[] Tipo;
            set_Tipo(Mo.Tipo);
        }
    }

    bool Motocicletta::operator==(const Motocicletta &Mo)const{
        return(this->Veicolo::operator==(Mo) && !(strcmp(Tipo, Mo.Tipo)));
    }

    bool Motocicletta::operator!=(const Motocicletta &Mo)const{
        return(! this->operator==(Mo));
    }

    ostream &operator<<(ostream &out,const Motocicletta &Mo){
    
        Mo.stampa(out);
        return out;
    }

    istream &operator>>(istream &in, Motocicletta &Mo){

        Mo.leggi(in);
        return in;
    }

    ostream &Motocicletta::stampa(ostream &out)const{
        Veicolo::stampa(out);
        out<<"| Tipo: "<<Tipo<<endl;
        return out;
    }

    istream &Motocicletta::leggi(istream &in){
        buffer b;
        Veicolo::leggi(in);
        in.getline(b, N_MAX-1, '\n');
        set_Tipo(b);
        in.ignore();
        return in;
    }

    const char *Motocicletta::Totext(){
        char *StringaMo;
        StringaMo=new char [strlen(Veicolo::Totext())+strlen(Tipo)+1];
        strcpy(StringaMo, Veicolo::Totext());
        strcat(StringaMo, Tipo);
        return StringaMo;
    }

}

Automobile libreria:

C++:

#ifndef AUTOMOBILE_H
#define AUTOMOBILE_H

#include "Veicolilib.h"

namespace Myprog{

    class Automobile : public Veicolo{
    
        friend ostream &operator<<(ostream &,const Automobile &);
        friend istream &operator>>(istream &, Automobile  &);
    
        private:
            char *Alimentazione;
    
        protected:
            virtual ostream & stampa(ostream &)const;
            virtual istream & leggi(istream &);

    
        public:
            Automobile(const char * = "", const char * ="", const char * ="");
            Automobile(const Automobile &);
            ~Automobile() { delete [] Alimentazione; };
        
            void set_Alimentazione(const char *);
        
            const char * get_Alimentazione(){ return Alimentazione; };
        
            const Automobile &operator=(const Automobile &);
            bool operator==(const Automobile &)const;
            bool operator!=(const Automobile &)const;
        
            virtual const char * Totext();
        
    };

}

#endif

Automobili funzioni:

C++:

#include "Automobile.h"

namespace Myprog{

    Automobile::Automobile(const char *N, const char *M, const char *A):Veicolo(N,M) { set_Alimentazione(A); };
    Automobile::Automobile(const Automobile & Au) :Veicolo(Au.Nometipo, Au.Marca){ set_Alimentazione(Au.Alimentazione); };

    void Automobile::set_Alimentazione(const char *A){
        Alimentazione=new char [strlen(A)+1];
        strcpy(Alimentazione, A);
    }

    const Automobile & Automobile::operator=(const Automobile &Au){
        if(&Au !=this){
            Veicolo::operator=(Au);
            if(Alimentazione) delete[] Alimentazione;
            set_Alimentazione(Au.Alimentazione);
        }
    }

    bool Automobile::operator==(const Automobile &Au)const{
        return(this->Veicolo::operator==(Au) && !(strcmp(Alimentazione, Au.Alimentazione)));
    }

    bool Automobile::operator!=(const Automobile &Au)const{
        return(! this->operator==(Au));
    }

    ostream &operator<<(ostream &out,const Automobile&Au){
    
        Au.stampa(out);
        return out;
    }

    istream &operator>>(istream &in, Automobile &Au){

        Au.leggi(in);
        return in;
    }

    ostream &Automobile::stampa(ostream &out)const{
        Veicolo::stampa(out);
        out<<"| Alimentazione: "<<Alimentazione<<endl;
        return out;
    }

    istream &Automobile::leggi(istream &in){
        buffer b;
        Veicolo::leggi(in);
        in.getline(b, N_MAX-1, '\n');
        set_Alimentazione(b);
        in.ignore();
        return in;
    }

    const char *Automobile::Totext(){
        char *StringaAu;
        StringaAu=new char [strlen(Veicolo::Totext())+strlen(Alimentazione)+1];
        strcpy(StringaAu, Veicolo::Totext());
        strcat(StringaAu, Alimentazione);
        return StringaAu;
    }

}

Garage libreria:

C++:

#ifndef GARAGELIB_H
#define GARAGELIB_H

#include "Veicolilib.h"
#include "Motolib.h"
#include "Automobile.h"
#include "Error.h"

#define V_MAX 100

using namespace std;

namespace Myprog{

    typedef Veicolo* pntVeicolo;

    class Garage{
    
        private:
            pntVeicolo vett[V_MAX];
            int count;
    
        public:
            Garage():count(0){for(int i=0; i<V_MAX; i++)vett[i]=0;};
        
            int immetti(Veicolo *);
            pntVeicolo estrai (const int);
            bool isFull(){ return count==0; };
            bool isEmpty(){ return count==V_MAX; };
            void stampa_video()const;
            void stampa_file(const char *)const throw(const char *);
            const char * unisci(const int );
            virtual const char * Totext();
    
    };
}
#endif

Garage funzioni:

C++:

#include "Garagelib.h"

namespace Myprog{

    int Garage::immetti(Veicolo *V){
        if(count<=N_MAX){
        vett[count]=V;
        count++;
        return count;
        }else return -1;
    }

    pntVeicolo Garage::estrai(const int num){
        if(count>=num){
            pntVeicolo temp= vett[num];
            for(int i=num; i<count; i++){
                vett[i]=vett[i+1];
            }
            count--;
            return temp;
        }
    }

    void Garage::stampa_video()const{
        for(int i=0; i<V_MAX; i++){
            if(vett[i]){
                cout<<vett[i]<<endl;
            }
        }
    }

    const char *Garage::Totext(){
        char *StringaGa;
        char test1[]="Automobile";
        if( !strncmp(Veicolo::Totext(), test1, 10)){
            StringaGa= new char [strlen(Automobile::Totext())];
            strcpy(StringaGa, Automobile::Totext());
        }else {
            StringaGa= new char [strlen(Motocicletta::Totext())];
            strcpy(StringaGa,Motocicletta::Totext());
        }
        return StringaGa;
    }

    void Garage::stampa_file(const char *nomefile )const throw(const char *){
        ofstream file;
        file.open(nomefile);
        if(!file)throw("Errore durante l'apertura del file'");
        for(int i=0; i<N_MAX; i++){
                file<<vett[i].Totext()<<endl;
        }
        file.close();
    }

}

Vi allego un link per la foto degli errori:

https://imgur.com/2Khqj8t

rodhellas · 12 Dicembre 2018

Tutto sto popò de roba, ma il main? :boh:
Hai istanziato degli oggetti di tipo Veicolo, Automobile e Motocicletta?

JayX · 12 Dicembre 2018

Potrebbe essere un errore nell'inclusione delle classi.

Mursey · 12 Dicembre 2018

Beh, l'errore parla chiaro, ed in effetti io vedo dei riferimenti alle classi ma non alle loro istanze.

Cerca

DOMANDA Una funzione funziona in due classi ma non in altre perchè?

Mr.Cobra

Nuovo Utente

rodhellas

JayX

Utente Attivo

Mursey

Super Moderatore

Ci sono discussioni simili a riguardo, dai un'occhiata!

Entra

Discussioni Simili