3. virtuielle funktionen, abstrakte klassen vererbung ..

virtuielle funktionen, abstrakte klassen vererbung ..

  • I

    hallo,

    hab mal wieder ein problem und es dreht sich mal wieder um warteschlangen! 🙄

    also es soll eine abstrakte klasse mit reinen virtuellen elementfunktionen geschrieben w
    erden, soweit so gut, hab da mal dieses hier:

    class Behaelter {			
	public:
		virtual void insert(Person *) = 0;
		virtual Person * remove(void) = 0;
		virtual bool isFull(void) = 0;
		virtual bool isEmpty(void) = 0;
		virtual Person * getFirst(void) = 0;
		virtual bool hasNext(void) = 0;
		virtual Person * getNext() = 0;
};

    von dieser klasse sollen die klassen Queue und Stack abgeleitet werden um für Queue eine zyklische Warteschlange für Person Objekte und Stack als Stabel für Person objekte zu realisieren! *omg*

    da hab ich dieses hier erstma:

    class Queue : public behaelter {
	public:
		void insert(Person *);
		Person * remove(void);
		bool isFull(void);
		bool isEmpty(void);
		Person * getFirst();
		bool hasNext(void);
		Person * getNext();

};

class Stack : public behaelter {
	public:
		void insert(Person *);
		Person * remove(void);
		bool isFull(void);
		bool isEmpty(void);
		Person * getFirst();
		bool hasNext(void);
		Person * getNext();
};

    also das ging ja noch 🙂
    jetzt soll über den konstruktor die behälterklassen initialisiert werden! öh? behälterklassen??
    Dazu kommt, dass ich ein Feld von Pointern vom Elementtyp Person * brauche das über den konstruktor initialisiert werden soll?! natürlich mit speicherbereich bereitstellen und so .. von einer länge 13

    für Person soll folgende klassenhierarchie verwendet werden, die hab ich schon fertig geproggt :p

    // Oberklasse

class person {
	private:
		char name;
		int id;
	public:
		person(char name, int id);
		virtual ~person() { };
		void setID(int setI);
		int getID();
		void setName(char setN);
		char getName();
		virtual float bezahlung() = 0;
};
person::person(char name, int id) {
	name = name;
	id = id;
}

void person::setID(int setI) {
	id = setI;
}
int person::getID() {
	return id;
}
void person::setName(char setN) {
	name = setN;
}
char person::getName() {
	return name;
}

// Klasse Angestellter, abgeleitet von person
class angestellter : public person {
	private:

	public:
		float gehalt;
		virtual ~angestellter() { };
		angestellter(char name, int id);
		void setGehalt(float setG);
		float getGehalt();
		virtual float bezahlung();
};
angestellter::angestellter(char name, int id) : person(name,id){

}
void angestellter::setGehalt(float setG) {
	gehalt = setG;
}
float angestellter::getGehalt() {
	return gehalt;
}
float angestellter::bezahlung() {
	return gehalt;
}

// Klasse Arbeiter, abgeleitet von person
class arbeiter : public person {
	private:
		float stundenlohn;
		float anzahlstunden;
	public:
		arbeiter(char name, int id);
		virtual ~arbeiter() { }
		void setStundenlohn(float setS);
		float getStundenlohn();
		void setAnzahlstunden(float setA);
		float getAnzahlstunden();
		float bezahlung();
};
arbeiter::arbeiter(char name, int id) : person(name,id){
}
void arbeiter::setStundenlohn(float setS) {
	stundenlohn = setS;
}
float arbeiter::getStundenlohn() {
	return stundenlohn;
}
void arbeiter::setAnzahlstunden(float setA) {
	anzahlstunden = setA;
}
float arbeiter::bezahlung() {
	return stundenlohn*anzahlstunden;
}

// Klasse Verkaeufer, abgeleitet von angestellter!
class verkaeufer : public angestellter {
	private:
		float provision;
	public:
		verkaeufer(char name, int id);
		virtual ~verkaeufer() { }
		void setGehalt(float setG);
		float getGehalt();
		void setProvision(float setP);
		float getProvision();
		float bezahlung();
};
verkaeufer::verkaeufer(char name, int id) : angestellter(name,id){

} 
void verkaeufer::setGehalt(float setG) {
	gehalt = setG;
}
float verkaeufer::getGehalt() {
	return gehalt;
}
void verkaeufer::setProvision(float setP) {
	provision = setP;
}
float verkaeufer::getProvision() {
	return provision;
}
float verkaeufer::bezahlung() {
	return gehalt+provision;
}

    kommt euch bekannt vor, wa? 🙂 war schon n paar threads vorher!

    soweit so gut. natürlich sollen die funktionen auch was machen und so, aber das krieg ich denke ich ma hin. mein problem is eigentlich nur wie ich dieses Person * deklariere und wo es initialisiert wird!

    ich weiss das is jetzt viel text und code aber vielleicht hat ja doch jemand zeit und bock sich damit ein wenig auseinanderzusetzen ..

    so .. kann mir da jemand helfen?? falls noch fragen sind .. alle man posten und fragen! danke und gruss ..

    0
  • I

    *hochschieb* .. keiner ne idee?

    in der klasse person muss uebringens alles person gross also so "Person"

    waere cool wenn da jemand irgend n vorschlag haette .. bei den anderen aufg hats ja bis jetzt auch immer geklappt!

    0
  • P

    also nur mal so zum verständnis - die Klasse behaelter ist eine abstrakte klasse und die klasse person auch.... wie sollen denn von abstrakten klassen objekte erzeugt werden??? man kann hier nur objekte der abgeleiteten klassen erstellen....

    Du kannst lediglich ne zeiger auf die abstrakte klasse machen

    Beipiel:

    Behaelter *b;
Behaelter *c;

b= new Queue(); // konstruktor der klasse Queue hier nen default...
c= new Stack(); // konstruktor der klasse Stack...

Person *p;
Person *g;
p= new Mitarbeiter(); // ja und so weiter

    das ganze nennt man dynamisches binden in der Laufzeit... Polymorphie. ich hoffe ich habe dein Problem richtig verstanden....

    0
Anmelden zum Antworten