[C++]STL-wyswietlanie list

Witam, mam taki problem, otoz mam taka oto klase:

class szkola
{
      private:
              list <uczen*> listaUczniow;
              list <nauczyciel*> listaNauczycieli;
              list <przedmiot*> listaPrzedmiotow;
       public:
             void wyswietlNauczyciel();
             void wyswietlUczniow();
             void wyswietlPrzedmioty();
}

I mam do tego metody wyswietlajace dane listy, tylko sa to metody oddzielne dla kazdej z tych list. Jednak chcialbym zrobic to tak zeby to byla uniwersalna metoda wyswietlajaca do tych wszystkich list. Pomozecie?

void wyswietlAll() {wyswietlNauczyciel();wyswietlUczniow(); wyswietlPrzedmioty(); } czy nie zrozumialem..?

tutaj sa te metody

void dziekanat::wyswietlPrzedmioty()
{ 
     list<przedmiot*>::iterator i;
     for(i=listaPrzedmiotow.begin(); i!=listaPrzedmiotow.end(); i++)
     {
                         cout << **i;
     }
}

void dziekanat::wyswietlUczniow()
{ 
     list<uczen*>::iterator i;
     for(i=listaUczniow.begin(); i!=listaUczniow.end(); i++)
     {
                         cout << **i;
     }
}

void dziekanat::wyswietlNauczycieli()
{ 
     list<nauczyciel*>::iterator i;
     for(i=listaNauczycieli.begin(); i!=listaNauczycieli.end(); i++)
     {
                         cout << **i;
     }
}

oczywiscie zeby to dzialalo przeciazylem operator <<

niestety, zle zrozumiales, chodzi mi o to zebym mial np taka metode:

wyswietl (lista);

i zeby wyswietlalo mi liste ktora podaje w argumencie.
Chce to zrobic po zeby moj kod nie byl az tak rozlegly i zeby ta funkcja byla unwiersalna do wszystkich list.

Da się, ale pod warunkiem, że dobrze zaprojektowałeś klasy: uczen, nauczyciel, przedmiot; i wszystkie mają wspólną klasę bazową.

e tam.. jezeli wszystkie z uzywanych elementow (uczen, nauczyciel, przedmiot) rzeczywiscie maja poprawny operator <<, to ich tresc jest juz poza tym nieistotna.. meet the Templates:

class dziekanat
{
....
    template<T>
    void wyswietl(std::list<T*> & lista)
    { 
        std::list<T*>::iterator i;
        for(i=lista.begin(); i!=lista.end(); ++i)
            cout << **i;
    }
}

class szkola
{
    private:
        list <uczen*> listaUczniow;
        list <nauczyciel*> listaNauczycieli;
        list <przedmiot*> listaPrzedmiotow;

    protected:
        template<class T>
        static void wyswietl(const list<T*>& values);

    public:
        void wyswietlNauczyciel() { wyswietl(listaUczniow); }
        void wyswietlUczniow() { wyswietl(listaNauczycieli); }
        void wyswietlPrzedmioty() { wyswietl(listaPrzedmiotow); }
};

/* To musi być w pliku nagłówkowym zaraz po deklaracji klasy */
template<class T>
void szkola::wyswietl(const list<T*>& values)
{
    typename list<T*>::const_iterator i;
    for(i=values.begin(); i!=values.end(); ++i) cout << **i;
};

dopisane:
Ja p.... - dlaczego jak już coś zacznę pisać, to musisz mnie wężu wyprzedzać ;)

racja, zapomnialem typename

ok, dzieki wielkie, dziala ladnie :-) pozdrawiam

Zastanawialem sie czy dobre byloby zastosowanie takiego szablonu do dodawania do list uczniow, nauczycieli i przedmiotow. Co o tym sadzicie?

nie wystarczy Ci std::push_back...?