✔ Operator >= überladen für template-Klasse

[Jennesta]

Hey Leute,
ich habe ein Problem beim überladen des Operators '>=".
Folgender Sachverhalt:
Ich habe eine template-Klasse erstellt die einen Stack darstellen soll.
Der Stack lässt sich wunderbar füllen, jeweils mit Daten des Typs Student, wofür ich eine eigene Klasse erstellt habe.
Nun muss ich den Stack nach der Matrikelnummer sortieren. Ich habe die Operatoren zuvor in der Klasse Student überladen und dort hat der Vergleich auch funktioniert.
Nun vergleiche ich aber in der Template-Klasse wodurch mir der linke Operand fehlt.
Meine Frage ist wie kann ich darauf zugreifen?

Die Funktion in Student sieht folgendermaßen aus.

// Größer-Operator
bool Student::operator >= (const Student& stud) {
	if (matNr >= stud.matNr)
		return true;
	else
		return false;
}

getestet habe ich dies folgendermaßen :

if (stud1 >= stud2) {
		cout << "Stud1 ist größer oder gleich" << endl;
	} else {
		cout << "Stud1 ist kleiner" << endl;
	}

Nun möchte ich diesen vergleich so verwenden:

template<int size, class T>
bool StackSpeicher<size, T>::operator >= (const Student& stud) {
	if (matNr >= stud.matNr)
		return true;
	else
		return false;
}

T ist hier die Klasse Student.
Wie gesagt macht der Compiler am roten Teil ärger, was ich verstehen kann, da er ja matNr nicht kennt.
Daher die Frage wie greife ich auf den linken Operanden zu?
Falls noch mehr Code benötigt wird bitte sagen.

lg Jennesta

 

[deepthroat]

Hi.

Du möchtest also folgendes:

StackSpeicher<Student> stud_stack;
Student s1;

if (stud_stack >= s1) {
  ...
}

Was willst du denn damit ausdrücken? Was soll es bedeuten wenn ein Stack (von Studenten) größer/gleich einem Studenten ist?

Außerdem ist ein Stack eine LIFO Struktur. Wenn du den Stack sortierst zerstörst du damit natürlich diese Eigenschaft. Wozu soll das gut sein?

Gruß

 

[Jennesta]

Die Frage nach dem Sinn ist durchaus berechtigt, jedoch soll ich das so implementieren auch wenns nicht dem Sinn des Stacks entspricht.
Aufgabe war, dies mit dem Quicksort Algorithmus zu sortieren. Und dort brauche ich halt den Vergleich. Hier den Auszug.

int StackSpeicher<size, T>::partition(int l, int r) {
	T temp;
	int k = r;
	T v = space[k];
	int i = l;
	int j = r-1;
	while(1) {
		while(space[i] <= v && i < r) i++;
		while(space[j] >= v && j >= r) j--;
		if(i >= j)
			break;
		else {
			temp = space[i];
			space[i] = space[j];
			space[j] = temp;
		}
	}
	temp = space[i];
	space[i] = space[k];
	space[k] = temp;
	return i;
}

So in der Art stand der Algorithmus letztes Jahr in meinem Vorlesungsskript und ich habe ihn nun versucht von einem Sortieralgorithmus von einem Array auf einen Stack mit Studentendaten umzubauen.

space ist hier ein Array bestehend aus daten des Typs Student und befindet sich als private variable im StackSpeicher.
ich will hier also die einzelnen Studenten vergleichen und dazu muss ich halt in den Studenten rein und die Matrikelnummer besorgen.

 

[Matthias Reitinger]

ich will hier also die einzelnen Studenten vergleichen und dazu muss ich halt in den Studenten rein und die Matrikelnummer besorgen.

Wieso? Du kannst Studenten doch schon dank des überladeten >=-Operators vergleichen. Der Stack muss (und sollte) überhaupt keinen Zugriff auf den internen Zustand seiner Elemente haben. Sonst ginge ja auch der schöne Vorteil des Templates verloren (Implementierung ist unabhängig von den konkreten Werten der Templateparameter).

Grüße, Matthias

 

[Jennesta]

Das klingt logisch.
Aber irgendwie verfängt sich das Programm während dem sortieren in einer Endlosschleife, vesshalb ich auf nicht funktionierende Operatoren geschlossen habe.
Nämlich geht das Programm nie in die beiden inneren Schleifen hinein...wesshalb i+j immer gleich bleiben.


€:: Ok hat sich erledigt....
danke für die Hilfe dadurch ist mri der Fehler erst aufgefallen.