Per Funktion Eigenschaften von mehreren Instanzen einer Klasse abfragen

Hallo Leute,

mein Problem, ich habe eine Klasse mit paar Eigenschaften...
nun lege ich ein Objektfeld an....und möchte jetzt, mit einer funktion, 2 werte von allen instanzen anzeigen lassen

zB, Klasse arbeiter, von allen Arbeiterobjekten die Namen und Vornamen
habs so versucht:

KLASSE:

class Arbeiter
{
private:
 string name;
 string vorname;
 string ort;
 static int numbers;
public:
 Arbeiter(){numbers++;}
 void SetName(string _name){name=_name;}
 void SetVorname(string _vname){vorname=_vname;}
 void SetOrt(string _ort){ort=_ort;}
 string GetName()const{return name;}
 string GetVorname()const{return vorname;}
 static int GetNumbers(){return numbers;}
 ~Arbeiter(){numbers--;}
};
int Arbeiter::numbers=0;

Zum anzeigen hab ich das mal in 2 Funktionen aufgesplittet:

void PrintStudent(const Student &stud)         
{
 cout<<stud.GetName()<<" "<<stud.GetVorname();
}

void PrintList()                   //wie muss diese Funktion aussehen???
{
 int x = Student::GetNumbers();
 for(int i = 0;i<x;i++)
 {
  PrintStudent(stud[i]);
  cout<<endl;
 }
}

wäre dankbar für eure hilfe

PS: nicht an den Student unten wundern, hatte Klasse erst mit Student....(hab grad erst auf Arbeiter gewechselt...nur die funktionen noch nicht, hab ich hier grad vergessen)!

Woems

void PrintList(const vector<Student> &stud)
{
 for(vector<Student>::iterator i=stud.Begin();i!=stud.End();++i)
 {
  PrintStudent(*i);
  cout<<endl;
 }
}

Ich hoffe ich hab dich richtig verstanden. (Code ungeprüft. Könnte also Fehler beinhalten)

also bitte erstmal ohne vectoren(denn soweit bin ich noch nicht)

Also ich meine....:
Ich lege ein Objektfeld an...

Arbeiter Arbeitnehmer[10];

und in einer schleife fülle ich alles aus...

string name,vname,ort;
for(int i = 0;i<10;i++)
{
 cin>>name >>vname >>ort;
 Arbeitnehmer[i].SetName(name);
 Arbeitnehmer[i].SetVorname(vname);
 Arbeitnehmer[i].SetOrt(ort);
}

so....

und jetzt möchte ich das bei PrintList(), alle Namen und Vornamen von den ganzen Arbeitnehmern(Instanzen) ausgespuckt werden....

hm...kann mir da keiner helfen?

void print_arbeiter(Arbeiter const &inst){
    cout<<inst.GetName()<<" "<<inst.GetVorname();
}

void print_list(const Arbeiter *array,size_t len){
   for(unsigned int i=0;i<len;i++)
         print_arbeiter(array[i]);
}

oder mit std::for_each.

Evtl. solltest du deiner Arbeiterklasse eine virtuelle print-methode verpassen.
Wenn du mal spezielle arbeiter hast, dann brauchst du am ausgabecode nichts ändern.
Natürlich würd dann im code statt print_arbeiter die methode print der entsprechenden instanz aufgerufen.

ser1al

ich hab das mal so gemacht:

void PrintStudent(const Student &stud)
{
 cout<<stud.GetName()<<" "<<stud.GetVorname();
}

void PrintList(Student *stud)
{
 int x = Student::GetNumbers();      //static methode,die anzahl der instanzen rurueckgibt
 for(int i = 0;i<x;i++)
 {
  PrintStudent(stud[i]);
  cout<<endl;
 }
}

und in main:

int main(int argc, char* argv[])
{
Student stud[2];
PrintList(stud);
}

hm...danke schonmal...

@prolog, was meinst mit einer virtuellen methode?
Kannst mir das etwas genauer erklären für was und wie?

prolog

Nehmen wir an du kannst absehen dass es nicht bei der arbeiterklasse bleibt sondern dass nach und nach ganz spezielle arbeiter hinzukommen. Meinetwegen management und fliessbandarbeiter. Sie alle haben einen namen und eine adresse aber unterschiedliche orte wo sie arbeiten zum beispiel.

Wenn dus so machen würdest wie jetzt müsstest du für jede art arbeiter eine eigene printmethode schreiben.

Wenn du aber sagst, dass ein manager ein arbeiter ist und ein fliessbandarbeiter ebenfalls, dann kannst du in der basisklasse arbeiter eine virtuelle methode print declarieren die gegebenenfalls von den abgeleiteten klassen überschrieben werden kann. Das ganze fällt unter das stichwort polymorphie

Mal ein beispiel

class arbeiter{
  public:
   arbeiter(string n,string l):name_(n),location_(l){}
   virtual ~arbeiter(){}
   //diese methode kann von abgeleiteten klassen überschrieben werden
   virtual void print(); 
  protected:
    string name_;
    string location_;
};

class manager : public arbeiter{
   public:
      manager(string n,string l):arbeiter(n,l){}
      void print(); //ueberschreiben der methode der basisklasse
};

class fliessbandarbeiter : public arbeiter{
   public:
     fliessbandarbeiter(string n,string l) : arbeiter(n,l){}
     void print(); //wieder überschrieben
};

//implementiereung

void arbeiter::print(){
  cout<<"name: "<<name_<<endl;
  cout<<"ort: "<<location_<<endl;
  cout<<"arbeitsort: firma"<<endl<<endl;;
}

void manager::print(){
  cout<<"name: "<<name_<<endl;
  cout<<"ort: "<<location_<<endl;
  cout<<"arbeitsort: buero"<<endl<<endl;
}

void fliessbandarbeiter::print(){
  cout<<"name: "<<name_<<endl;
  cout<<"ort: "<<location_<<endl;
  cout<<"arbeitsort: fliessband"<<endl<<endl;;

}

static void print_workers(arbeiter **w,const size_t len){
   for(unsigned int i=0;i<len;i++)
       w[i]->print(); //jetzt wird abhängig vom genauen typ die entsprechende methode aufgerufen
 }

Benutzung. Polymorphy funktioniert nur mit zeigern oder referenzen.
Nehmen wir an deine methode print bekommt ein array von zeigern auf arbeiter.

arbeiter *workers[3];
 workers[0]=new arbeiter("arbeiter1","ort1");
 workers[1]=new manager("arbeiter2","ort2");
 workers[2]=new fliessbandarbeiter("arbeiter3","ort3");
 print_workers(workers,3);

Ausgabe: