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]

modificato

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

[19semplicemente]

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

[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]

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]

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"); // :p
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]

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

[19semplicemente]

scusami .. ma .. come me ne esco dal problema? nn ho capito! :cry:

[fek]

scusami .. ma .. come me ne esco dal problema? nn ho capito! :cry:

Dando per scontato che non ti scrivo io la soluzione :) quale problema non riesci a risolvere di preciso? il core dump o la stampa?

Per il core dump: usa std::string. Per la stampa: scegli fra una delle tre soluzioni che ti ho proposto.

Prova a scrivere il codice, compila e poi esegui e vedi se il risultato e' quello che ti serve.

[19semplicemente]

il problema è che devo usare per forza un puntatore cioè un campo vuole che sia per forza un puntatore...

scusa l'ignoranza ma sul mio libro non dice cos'è un core dump... :confused:

[fek]

il problema è che devo usare per forza un puntatore cioè un campo vuole che sia per forza un puntatore...

scusa l'ignoranza ma sul mio libro non dice cos'è un core dump... :confused:

Quale campo?
Un core dump significa che il tuo programma va in crash.

Un passo per volta, scrivi qui la classe persona, con costruttore e distruttore. Prova a usare std::string.

[19semplicemente]

ok ora la scrivo e poi la posto...

[19semplicemente]

class persona {
protected:
string *nome;
string *cognome;

public:
persona(string n, string c){
nome = new string;
cognome = new string;

*nome = n;
*cognome = c;
}

~persona(){ delete nome; delete cognome;)
};

[19semplicemente]

devo usare per forza i puntatori per le stringhe, altrimenti non posso allocare memoria dinamica...
solo che poi ho problemi a stampare ...

[19semplicemente]

ciao.. ho provato a modificare così.. ora stampa.. ma crasha subito dopo .. come mai?!

#include <iostream>
#include <string>

using namespace std;

class persona {
protected:
string *nome;
string *cognome;

public:
persona(string n, string c){
nome = new string;
cognome = new string;

*nome = n;
*cognome = c;

//cout << *nome;
}

~persona(){ delete nome; delete cognome;}

void print(persona ogg){ cout << *ogg.nome ;}
};


int main()
{
persona giovanni("michele", "giuliano");

giovanni.print(giovanni);


return 0;
}

[fek]

devo usare per forza i puntatori per le stringhe, altrimenti non posso allocare memoria dinamica...
solo che poi ho problemi a stampare ...

Non devi allocare std::string dinamicamente, la devi usare come fosse un numero intero.

std::string nome = unNome;

La classe string si occupa di allocare/deallocare dinamicamente per te.

[19semplicemente]

non penso che potrò usarla all'esame.. perchè il prof vuole che usiamo tutta la procedura..

credo che dovrò usare i char... nome = new char[50]

ascolta se uso le stringhe nel distruttore cosa devo scrivere? niente?

[fek]

non penso che potrò usarla all'esame.. perchè il prof vuole che usiamo tutta la procedura..

credo che dovrò usare i char...

ascolta se uso le stringhe nel distruttore cosa devo scrivere? niente?

Ok, usa char*, ma diventa piu' complesso:

nome = new char[30];
strncpy(nome, n, 30); // copia 30 caratteri del nome dentro la stringa

Nel distruttore:

delete nome[];

[19semplicemente]

lo so ma... lui mi sa che vuole così..
io al max faccio una cosa..
nella prima uso i char, nella seconda le stringhe..

ora rimane una cosa...

quale overload di << mi consigli tu?

[19semplicemente]

ciao!
ho provato questa e funziona... però tu mi avevi detto di evitarla... :(

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

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

return os;
}

[19semplicemente]

e ...... se facessi così:
ostream &operator << (ostream &os, atleta ogg){
persona obj = ogg;

os << obj;
os << "Nazionalità: " << ogg.nazio << "\n" << "Disciplina: " << ogg.disciplina;

return os;
}

[fek]

Meglio il cast esplicito. Non e' elegantissimo, ma meglio della seconda versione.

[19semplicemente]

ok.. usero il cast...:)

grazie davvero :P

[PendragonJR]

uppo questo.


allora.

1)

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).


quindi quello che ho intuito è giusto no ? se uso il reference non devo usare nessun costruttore copia.


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

io non sto capendo.
cioè non capisco proprio come si possa utilizzare lo stesso operatore di "PERSONA" per dichiare il giocatore...
non ha senso.
il mio libro dice che gli overload degli operatori estrazione ed insirimento può essere fatto solo all'esterno delle classi.

quando tu parli di "metodi" intendi funzioni membro vero ?
se parliamo di funzioni membro non andiamo all'interno delle classi ?
se andiamo all'interno delle classi non entriamo in contraddizione con quanto dice lo shildt ? :muro: :muro: :muro:

[PendragonJR]

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

using namespace std;

class atleta{

protected:
int *eta;
char *nome[30];

atleta(char *n, int a) {
nome = new char;
strcpy(nome, n);
eta = new int;
*eta = a; //quando compilo qui mi da come out la locazione -__-
}

~atleta() {delete nome, eta;}


class calciatore : protected atleta{

public:
int *potenza_tiro;
int *precisione_tiro;

calciatore(char *n, int a, int b, int c) : atleta(n,a) {
potenza_tiro = new int;
precisione_tiro = new int;
*potenza_tiro = b;
*precisione_tiro = c;
}
~calciatore() {delete potenza_tiro, precisione_tiro;}


};


ostream &operator<<(ostream &stream, atleta &ob)

{

stream << ob.nome << '\n';
stream << ob.eta << '\n';
}

ostream &operator<<(ostream &stream, calciatore &ob)

{

stream << ob.nome << '\n';
stream << ob.eta << '\n';
stream << ob.precisione_tiro << '\n';
stream << ob.potenza_tiro << '\n';
}


int main() {

totti.calciatore("francesco",26,100,100);
cassano.calciatore("antonio",23,100,100);

cout << totti;
cout << '\n';
cout << cassano;

return 0;

}




questo frammento è corretto ?
concettualmente intendo.

a parte qualche puttanata che ci può stare (non posso compilarlo da qui... il portatile sul quale lavoro non è collegato in rete) funge...
con l'unico problema che non mi da i valori interi, ma bensì le locazioni.. e non riesco a capirne il motivo in quanto ho applicato di pari passo new così come sta sul libro.

[19semplicemente]

... qualcuno mi sa dire xkè crashia il programma quando si arriva alla stringa:

os >> ogg.marca ?!?

grazie

#include <iostream>
#include <string>

using namespace std;

class mezzo {
protected:
char *targa;
char *marca;
char *modello;

public:
mezzo(char *t, char *m, char *mod){
targa = new char[7];
marca = new char[10];
modello = new char[10];

targa = t;
marca = m;
modello = mod;
}

~mezzo(){
delete[] targa;
delete[] marca;
delete[] modello;
}

mezzo(const mezzo &ogg){
cout << "costruttore di copia\n";
targa = ogg.targa;
marca = ogg.marca;
modello = ogg.modello;

}

friend ostream &operator << (ostream &os, mezzo ogg);
friend istream &operator >> (istream &os, mezzo &ogg);
};

ostream &operator << (ostream &os, mezzo ogg){
os << "Marca: " << ogg.marca << endl;
os << "Modello: " << ogg.modello << endl;
os << "Targa: " << ogg.targa << endl;

return os;
}

istream &operator >> (istream &os, mezzo &ogg) {

int sc;
do{
cout << "Cosa si vuole modificare?" << endl;
cout << "1. Marca \n2. Modello \n3. Targa \n";
cin >> sc;
}while(sc<1||sc>3);

switch(sc){
case 1:
cout << "inserire la marca";
os >> ogg.marca;
break;

case 2:
os >> ogg.modello;
break;

case 3:
os >> ogg.targa;
break;
}

return os;
}

[19semplicemente]

help! :(