c++: ereditarierà e overload di operatori

[19semplicemente]

ciao a tutti...

ho una classe base A dove ho definito un overload per l'operatore <<;

ora voglio creare una classe B, derivata di A, e definire anche qui l'overload dell'operatore << sfruttando però l'overload gia esistente della classe A

tipo quanto succede per i costruttori:
classe B(int a, int b) : classe A(b)

dite ke è possibile? se si come si fa?

tnks

[fek]

Scrivi un esempio di codice compilabile di quello che vuoi fare.

[19semplicemente]

ho definito un overload << per club.. e ora lo voglio definire per giocatore, in modo che possa l'overload utilizzare quello di club

class club {
	protected:
        char *squadra;
    
    public: 
        club(){squadra = " ";}
        
        club(char *s){
         	
            squadra = new char[30];
        	squadra = s;
        }
        
        club(const club &ogg){
        	squadra = ogg.squadra;
        }
        
        ~club(){ delete [] squadra;}
        
        friend ostream &operator << (ostream &os, club ogg);
};

ostream &operator << (ostream &os, club ogg){
		
	os << "La squadra è: " << ogg.squadra;
	
	return os;
}

class giocatore : public club {
    protected:
        string *nome; 
        string *cognome;
    
    public:
        giocatore(){
        	*nome = " ";
        	*cognome = " ";
        }
        
        giocatore(string n, string c, char *s) : club(s){
        	nome = new string;
        	cognome = new string;
        
            *nome = n;
            *cognome = c;
        }
        
        ~giocatore(){ delete nome; delete cognome;}
        
        friend ostream &operator << (ostream &os, giocatore ogg);
};

ostream &operator << (ostream &os, giocatore ogg){
	
		os << ogg.nome << " " << ogg.cognome;
	return os;
}

int main(){
	
		giocatore Maldini("P", "M", "Milan");
      
      cout << Maldini;
      
        	return 0;
}

[fek]

Puoi indentarlo per favore?

Perche' erediti giocatore da club?

[19semplicemente]

modificato

[fek]

Originariamente inviato da 19semplicemente

modificato

Grazie. Ora rispondi a questa domanda per favore:
"Giocatore e' un Club?"

[19semplicemente]

xkè così mi chiede di fare la traccia..

[19semplicemente]

si hai ragione.. ma la traccia diche che devo creare una classe giocatore e poi derivarla...

ho pensato di fare il contrario ma.. bho.. non mi veniva niente in mente...

[fek]

Originariamente inviato da 19semplicemente

si hai ragione.. ma la traccia diche che devo creare una classe giocatore e poi derivarla...

ho pensato di fare il contrario ma.. bho.. non mi veniva niente in mente...

La traccia di un esame ti chiede di derivare giocatore da club??????
Oppure di derivarlo da un'altra classe che decidi tu?

[19semplicemente]

la traccia diceva di creare una classe giocatore e poi derivarla...

sarò io che non ho fantasia.. ma non mi veniva niente!

[19semplicemente]

cmq... a me interessa sapere come si fa per l'overload.. poi magari pensiamo alla classe...

[fek]

Originariamente inviato da 19semplicemente

la traccia diceva di creare una classe giocatore e poi derivarla...

sarò io che non ho fantasia.. ma non mi veniva niente!

Ok, capito.

Deriva da una classe Persona che ha un nome e un cognome e poi aggiungi la squadra.

"Giocatore e' una Persona"

Riscrivilo cosi' e poi rispondo all'altra domanda

[19semplicemente]

cioè devo creare una classe persona e metterci nome e cognome e poi in un'altra classe derivata metterci quadra?
il contrario di quello che ho fatto io praticamente?

[19semplicemente]

modificato a volo...

#include <iostream>
#include <string>

using namespace std;

class persona {
    protected:
        string *nome; 
        string *cognome;
    
    public:
        persona(){
        	*nome = " ";
        	*cognome = " ";
        }
        
        persona(string n, string c){
        	nome = new string;
        	cognome = new string;
        
            *nome = n;
            *cognome = c;
        }
        
        ~persona(){ delete nome; delete cognome;}
        
        friend ostream &operator << (ostream &os, persona ogg);
};

ostream &operator << (ostream &os, persona ogg){
	
		os << ogg.nome << " " << ogg.cognome;
	return os;
}

class giocatore : public persona{
	protected:
        char *giocatore;
    
    public: 
        giocatore(){giocatore = " ";}
        
        giocatore(string n, string c,char *s): persona(n,c){
         	
            giocatore = new char[30];
        	giocatore = s;
        }
        
       
        
        ~giocatore(){ delete [] giocatore;}
        
        friend ostream &operator << (ostream &os, giocatore ogg);
};

ostream &operator << (ostream &os, giocatore ogg){
		
	os << ogg.giocatore;
	
	return os;
}


int main(){
	
		giocatore Maldini("P", "M", "Milan");
      
      cout << Maldini;
      
        	return 0;
}

[fek]

Non compila. Guarda la classe Giocatore, ha un costruttore di nome Club.
Poi con string* immagino tu voglia usare la classe std::string. Non hai bisogno del puntatore, puoi usare la classe per valore.

(Prima di postare il codice prova sempre a compilarlo, e' piu' facile aiutarti).

[19semplicemente]

modificato...

[19semplicemente]

va bhe il programma è da riscrivere.. cmq.. mi dici come si fa?

[fek]

Perfetto, ora la risposta alla tua domanda.

Tu vuoi che questo operatore stampi nome, cognome e squadra del giocatore e usi l'operatore di Persona gia' definito:

ostream &operator << (ostream &os, giocatore ogg){
		
	os << ogg.giocatore;
	
	return os;
}

Una piccola nota: gli operatori dichiarati friend e all'esterno della classe sono "free function" e non metodi, quindi non vengono ereditati, ma il compilatore sceglie quello giusto esaminando il tipo dei parametri passati:

giocatore Adriano("", "Adriano", "Inter"); //
cout << Adriano;

I due operatori di seguito sono entrambi eligibili, perche' Adriano e' un (gran) giocatore ed e' una persona:

ostream &operator << (ostream &os, persona ogg)
ostream &operator << (ostream &os, giocatore ogg)

Il compilatore sceglie quello piu' vicino al tipo dell'oggetto, in questo caso il secondo (risoluzione dell'overloading).

Il tuo problema non e' banale da risolvere, ti propongo qualche soluzione.

Numero uno:

ostream &operator << (ostream &os, giocatore ogg){
		
        os << ogg.nome;
        os << ogg.cognome;
	os << ogg.giocatore;
	
	return os;
}

Non e' elegantissima.
Una soluzione piu' elegante sarebbe dichiarare un metodo print(ostream& os) in persona e scrivere:

ostream &operator << (ostream &os, giocatore ogg){
        ogg.print(os);

	os << ogg.giocatore;
	
	return os;
}

Puoi riusare print() nell'operatore << di persona.

Ultima soluzione (ma non ho un compilatore fra le mani, e a memoria non ricordo se e' legale), puoi provare a forzare esplicitamente la risoluzione dell'overloading:

ostream &operator << (ostream &os, giocatore ogg){

        os << (persona&) ogg;    // cast esplicito
	os << ogg.giocatore;
	
	return os;
}

Non e' elegantissimo, io lo eviterei religiosamente.

Infine, tutto il discorso e' inutile perche' quello che hai scritto va in core dump
Ecco il problema:

giocatore = new char[30];
giocatore = s;

crei la stringa, poi assegni la stringa al puntatore che passi (i char* non sono oggetti, sono puntatori, errore tipico che si fa in C++ anche dopo anni), scartando la memoria appena allocata, poi nel distruttore fai:

~giocatore(){ delete [] giocatore;}

... distruggendo sotto il naso la memoria della stringa gestita da chi ha chiamato il metodo. Se la stringa era allocata sullo stack, va in core dump direttamente qui, altrimenti andra' in core dump (se va bene, ma succede anche di peggio) quando il possessore della stringa tentera' di distruggere una seconda volta quella memoria.
Ed infine, passi tutti gli oggetti per valore piuttosto che per reference (giocatore&), quindi c'e' di mezzo ad ogni chiamata all'operatore una costruzione e distruzione di un oggetto temporaneo. Indovina che cosa succede quando il compilatore distrugge l'oggetto temporaneo? (crasha tutto se ti va bene).

Usa std::string e la vita ti sorride. Non ti preoccupare per questi errori, sono tipici, li farai anche dopo anni, il C++ e' MOLTO complicato ed e' pieno di questi trabocchetti. Per questo lo sconsiglio cosi' vivacemente

[19semplicemente]

se nn fosse che lunedì ho l'esame

[fek]

Originariamente inviato da 19semplicemente

se nn fosse che lunedì ho l'esame

Tranquillo

Prova a finire correttamente questo esempio e ne saprai di piu' di chiunque altro a quell'esame