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

[Mr.Cobra]

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è?

Spoiler

Veicolo libreria

#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:

#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

#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:

#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:

#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:

#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:

#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:

#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:

Spoiler

http://imgur.com/2Khqj8t

 

[rodhellas]

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

 

[JayX]

Potrebbe essere un errore nell'inclusione delle classi.

 

[Mursey]

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