[C++] ereditare liste e main

[shodan]

Ora non volevo sollevare un polverone sulle funzioni o sulla traccia

Nessun polverone Diciamo che la cosa è strana perché non si fa mai per le ragioni esposte, e spero che tu abbia capito le ragioni per cui non si deve mai ereditare da un container STL. Se poi sei obbligato, amen.
Comunque ora il contesto in cui ti devi muovere è chiarissimo.

Detto questo, ai fini pratici, un'ereditarietà di tipo protected equivale a incorporare std::list all'interno di Squadra: il mondo esterno non può accedere direttamente ai metodi di std::list.
Quindi il main può usare solo i metodi esposti da Squadra, e mai quelli ereditati da std::list
Se erano queste le tue perplessità, spero di averle chiarite.

I metodi di Squadra dovrebbero (se possibile) avere nomi possibilmente significativi su quello che si vuole fare, ma non devono collidere con quelli di std::list pena ambiguità (al metodo di cosa dovrebbe riferirsi il compilatore?).
Un esempio disambiguo potrebbe essere:

class Squadra: protected list<Giocatore*> { 
    public:
        Squadra(Giocatore* cap) {
            this -> capitano =cap; 
            push_back(capitano); // ora non è ambiguo
            // o anche 
            // add_giocatore(cap); 
        }
        Squadra( const Squadra&); 
        ~Squadra(); 

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

Tuttavia se i metodi di Squadra sono preimpostati dalla traccia (come temo), le ambiguità si potrebbero risolvere premettendo un std::list<Giocatore*>::metodo_lista() per ogni funzione ambigua.

I giocatori.
Se anche qui la traccia prevede una ereditarietà protetta, la cosa è assurda dato che tutti i metodi pubblici di Giocatore diventano protected di Difensore e quindi non visibili al mondo esterno, rendendo di fatto inutile la relazione Difensore <- Giocatore.
Se ti serve il polimorfismo (come mi pare aver capito), l'ereditarietà dev'essere public e i vari metodi virtuali.

Però andando avanti a ipotesi non si fà molta strada.

[BlackWidow89]

ok, perfetto! ripeto: la traccia fornita comprendeva la definizione di squadra così come l'ho postata, ho aggiunto solo std::

quindi, inizialmente era proposta in traccia come
class Squadra: protected list<Giocatore*>

io, in quella definizione ho aggiunto solo std:: poiché, ripeto, mi dava errore relativamente a list.

No giocatore l'ho creata io da zero, la traccia forniva appunto quello che ho scritto nel post e l'header di Squadra.
Grazie mille per la pazienza, sono riuscita a capirci un qualcosa!