PDA

Visualizza la versione completa : [C++] ereditare liste e main


BlackWidow89
04-02-2016, 23:55
Salve ragazzi, evidenzio in breve il mio problema:
Ho una classe chiamata Squadra che eredita una lista protected di tipo <*Giocatore>


class Squadra::protected std::list<*Giocatore>

io dovrei implementare le funzioni di Giocatore ed a mio piacimento inserire altre classi che potrebbero essermi utili.

Ho creato la classe Giocatore senza problemi, poi ho creato come classi derivate i vari ruoli, poiché nella traccia mi veniva chiesta una certa elasticità riguardo i ruoli dei giocatori (quindi difensore, portiere, ecc avranno tutte questa impostazione:


Class Difensore: protected Giocatore


Ora, mi sorgono dei problemi relativi alla dichiarazione nel main di questi oggetti:



Non ho la minima idea di come dover utilizzare l'oggetto Squadra, non ho mai avuto a che fare con il richiamare una classe che erediti una lista, e sul web purtroppo ho trovato poco riguardo classi che ereditano liste.
Le funzioni della classe Squadra posso usarle solo su liste di puntatori a giocatori? o volendo potrei usarle anche su, per esempio, una lista di tipo puntatore a difensore (che è comunque ereditata da Giocatore?)


Purtroppo non so come muovermi, ho cercato sul web ma di esempi in cui si crea un main utilizzando classi così composte non ce ne sono. Ho fatto un po di prove ma purtroppo non riesco ad uscirne. Non inserisco il codice poiché al momento ho solo problemi concettuali nel capire come possa utilizzare Squadra.

In attesa di qualche anima pia che decida di aiutare una povera disperata, saluti!:ciauz:

shodan
05-02-2016, 13:22
Ereditare da un container STL è sconsigliato quanto darsi una martellata su un dito: possibile ma doloroso. I container STL non sono pensati per una possibile ereditarietà, in quanto manca il distruttore virtuale. E se la traccia lo prevede esplicitamente, è sbagliata la traccia.

Detto questo, una squadra ha un tot di giocatori, non é un insieme di giocatori.
Per cui dovresti fare:


class Squadra {
protected:
std::list<Giocatore*> players;

public:
void add_giocatore(Giocatore* g) {
players.push_back(g);
}
// altro
};

// da qualche parte nel main

Squadra team;

team.add_giocatore(new Attaccante);
team.add_giocatore(new Difensore);
team.add_giocatore(new Portiere);
team.add_giocatore(new Terzino);
team.add_giocatore(new CentroPanchina);
// etc...


Per le altre domande:
1) Come detto non si eredita da un container STL, si incorpora.
2) Dato che la lista è composta di puntatori a Giocatore, puoi usare solo le funzioni di tale classe base. Attraverso il polimorfismo, però, puoi ridefinire le funzioni virtuali della classe base affinché si adattino alle esigenze delle classi derivate. Se hai bisogno di richiamare singole funzioni delle classi derivate non previste dalla classe Giocatore, puoi farlo attraverso dei cast controllati.
Questa la teoria più o meno.
Prova a buttare giù qualcosa, ad esempio quello che vorresti fare (in codice), in modo da ragionarci su.

BlackWidow89
05-02-2016, 17:05
Il problema è che lo prevede la traccia dell esame, se fosse stato per me avrei fatto anche io creando la lista nella definizione dell header :(

shodan
05-02-2016, 19:57
Puoi postare la traccia?

BlackWidow89
06-02-2016, 16:32
Progettare la classe Giocatore tenendo conto che il sistema deve essere flessibile all aggiunta di un nuovo ruolo. Inserire in Giocatore tutti i metodi che si ritengono opportuni e mostrare la definizione di almeno una tipologia di Giocatore.
Implementare i metodi mancanti della classe squadra:


Class Squadra: protected list<Giocatore*>
{ public:
Squadra(Giocatore* cap) {this -> capitano =cap; push_back(capitano); }
Squadra( const Squadra&);
~Squadra();

void push_back(Giocatore*);
void remove(Giocatore*);
unsigned int size() cont;
void add(Giocatore*);
bool operator==(const Squadra&m) const;
friend ostrem& operator<<(ostream& out, const Squadra& m);
};

Le ho fatte le funzioni, il problema è capire come creare un main, in questa traccia non è richiesto ma in altre si, e non vorrei trovarmi all esame cascando dalle nubi ;D

MItaly
06-02-2016, 17:13
Ereditarietà protected :cry:
da un container STL :cry:
std::list :cry:

ma chi vi tiene il corso, topo gigio?

shodan
06-02-2016, 18:24
Progettare la classe Giocatore tenendo conto che il sistema deve essere flessibile all aggiunta di un nuovo ruolo. Inserire in Giocatore tutti i metodi che si ritengono opportuni e mostrare la definizione di almeno una tipologia di Giocatore.
Implementare i metodi mancanti della classe squadra:

Se questa è la traccia, non c'è scritto che devi ereditare da una std::list (come lasciavi presupporre dall'altro post), quindi hai deciso tu di farlo. E comunque insistere sull'ereditarieta di Squadra da std::list<Giocatore*> è sbagliato. Doppiamente sbagliato se non altro perché se si volesse sostituire la std::list con un std::vector la cosa non sarebbe indolore. Triplamente sbagliato perché non si capisce cosa dovrebbe rappresentare un: Squadra.push_back.
Le funzioni di Squadra dovrebbero rappresentare un'azione comprensibile e contestualizzata a quello che si sta facendo: è meglio Squadra.push_back o Squadra.add_giocatore?
Direi che sei decisamente fuori strada.


il problema è capire come creare un main

Francamente non capisco: nel main istanzi una classe e ne usi le funzioni. Cosa non è chiaro?

MItaly
06-02-2016, 18:43
Se questa è la traccia, non c'è scritto che devi ereditare da una std::list (come lasciavi presupporre dall'altro post), quindi hai deciso tu di farlo.
Sospetto che la traccia includa quello scheletro di classe Squadra, con i metodi da implementare. :spy:

shodan
06-02-2016, 23:09
Inizio a pensarlo anch'io, ma ancora rifiuto di crederci :)

BlackWidow89
07-02-2016, 05:00
Se questa è la traccia, non c'è scritto che devi ereditare da una std::list (come lasciavi presupporre dall'altro post), quindi hai deciso tu di farlo.

iL file squadra.h è fornito dalla traccia, quidni mi devo attenere a quello purtroppo.

Problema numero 1. il corso prevede l'utilizzo del terminale linux, su macchine che forse hanno un kernel con età più avanzata della mia, a.k.a. ho provato ad inserirlo senza inserire std ma usciva fuori un problema, che cercando sul web si poteva risolvere inserendo std:: lì, ovvio, non ho deciso di inserirlo io lì, ma visto che il compilatore dei multimillenari pc dell università funziona così, ho deciso di inserire std poiché non facendolo mi dava errore, provando a casa sul mio pc funzionava senza problemi ma su quelli con cui avrei dovuto dare l'esame l'errore consisteva, e l'esame si passa solamente con tracce che compilano ed eseguano un main senza errore.
Ora non volevo sollevare un polverone sulle funzioni o sulla traccia, il succo è appunto che UNA CLASSE EREDITA UNA LISTA PROTECTED DI PUNTATORI A TIPO CLASSE ed io non ho la minima idea di come poterla richiamare nel main.
Essendo un appello d'esame mi devo attenere a ciò che mi da l'esercitatore o il professore, ovvero quello.
Non sono io a scegliere le funzioni da inserire o come farle, il prof mi da questo "scheletro" ed io devo seguire questo per creare le classi di supporto e (main quando si richiede) per svilupparlo .

Loading