Vererbung und Überschreiben von Funktionen

Krondor

Hallöle,

hab ein kleines Problem und hoffe, dass ihr mir helfen könnt.
Ich programmiere schon seit längerem mit Java und wollte mir nun noch etwas C++ aneignen.

Nun wollte ich das bekannte State Pattern verwenden. In Java weiß ich wie es geht nur in C++ bekomme ich es einfach nicht hin.

Aus diesem Grund zeige ich euch was ich in C++ machen will anhand eines Java-Beispielcodes:

public class Main {
	public static void main(String[] args){
		Basis b = new Basis();
		Basis s1 = new Sub1();
		Basis s2 = new Sub2();

		b.test();
		s1.test();
		s2.test();
	}
}

class Basis{
	public void test(){
		System.out.println("Basis");
	}
}

class Sub1 extends Basis{
	public void test(){
		System.out.println("Sub1");
	}
}

class Sub2 extends Basis{
	public void test(){
		System.out.println("Sub2");
	}
}

Wie ihr seht gibt es zwei Klassen Sub1 und Sub2, welche von der Klasse Basis erben. Die Klasse Basis implementiert eine Methode test, welche von den beiden Subklassen überschrieben wird. Wenn ich nun in der MainMethode drei Variablen b,s1 und s2 erstellen, welche alle vom Typ Basis sind und ihnen jedoch Objekte vom Typ Basis, Sub1 und Sub2 übergebe und dann von allen Variablen die test-Funktionen aufrufe kommt folgendes Ergebnis heraus:

"Basis"
"Sub1"
"Sub2"

Es werden also die jeweiligen Methoden der untersten Klasse aufgerufen und nicht die Funktion der Oberklasse.

Nun habe ich versucht das ganze in C++ umzusetzen und habe mir das folgendermaßen vorgestellt:

#include <iostream>

using namespace std;

class Basis{
public:
	void test();
};

class Sub1:public Basis{
public:
	void test();
};

class Sub2:public Basis{
public:
	void test();
};

int main(){
	Basis* b = new Basis();
	Basis* s1 = new Sub1();
	Basis* s2 = new Sub2();

	b->test();
	s1->test();
	s2->test();

	return 1;
}

void Basis::test(){
	cout << "Basis" << endl;
}

void Sub1::test(){
	cout << "Sub1" << endl;
}

void Sub2::test(){
	cout << "Sub2" << endl;
}

Wenn ich nun die C++ Variante aufrufe kommt folgendes Ergebnis heraus:

"Basis"
"Basis"
"Basis"

Es wird also jedesmal die Methode der Oberklasse Basis aufgerufen anstatt die der untersten Klasse.

Kann mir nun jemand sagen wie ich das hinbekomme, dass es so funktioniert wie in der Java-Variante?

Im Endeffekt geht es darum, dass ich in ein OpenGL-Fenster verschiedene Objekte zeichnen können möchte, welche ich vorher nicht kenne.
Dazu habe ich eine Klasse Entity, welche die Oberklasse ist. Von ihr erben Klassen wie z.B. Cube o.ä..
Nun wollte ich halt eine Liste mit Objekten vom Typ Entity* durchlaufen, welche natürlich nicht wirklich Entities, sondern Cubes o.ä. sind und diese halt zeichnen, einfach indem ich die Methode draw von den Objekten aufrufe.
Also soll bei einem Würfel beispielsweise die Methode Cube::draw() und nicht Entity::draw() aufgerufen werden, ohne dass ich vorher weiß welcher Klasse das Objekt denn nun wirklich angehört.

Ich wäre echt froh über ne Antwort.

MfG,
Krondor

Simon2

Hi,

in C++ mußt Du bei der Deklaration sagen, wenn Du eine Funktion "überschreibbar" machen möchtest:
"virtual" davor und schon klappt's.

Krondor schrieb:

...
...

class Basis{
public:
	virtual void test();
...
void Basis::test(){
	cout << "Basis" << endl;
}

...

Ist ein wenig so, als ob "der Default" genau andersherum sei als in Java: Während Du dort immer überschreiben kannst, wenn nichts Anderes angegeben wird, wird hier (in C++) NICHT überschrieben, wenn man nichts anderes sagt.

Gruß,

Simon2.

Krondor

Yeah! Super!
Du hast mir sehr geholfen und dann auch noch so schnell.

Großes Dankeschön!

Simon2

Krondor schrieb:

Yeah! Super!
Du hast mir sehr geholfen und dann auch noch so schnell.

Großes Dankeschön!

Sehr gern geschehen !

Viel Vergnügen noch mit C++ und für weitere Fragen sind hier außer mir noch eine Menge anderer (teilweise sehr viel kompetentere) Leute unterwegs.

Gruß,

Simon2.