Polymorphie & abstrakte Klassen

Hi!

Ich habe eine abstrakte Klasse
"Merkmal".

class Merkmal
{
public:
virtual float getDistance(Merkmal m) = 0;
}

Davon erbt:

class Flächeninhalt: public Merkmal
{
virtual float getDistance(Flächeninhalt f) { return 0.0}
}

Obwohl Flächeninhalt ja auch ein Merkmal ist erkennt der Compiler das nicht.
Ok, habe ich ich mir gedacht schreibe ich statt dessen.
class Flächeninhalt: public Merkmal
{
virtual float getDistance(Merkmal m) { return 0.0}
}

Das geht aber auch nicht, weil natürlich von abstrakten Klassen keine Instanzen erstellt werden dürfen.

Von Merkmal sollen viele weitere Merkmale abgeleitet werden, die müssen alle eine Funktion haben getDistance. Flächeninhalt soll jedoch nur seine Distanz zu anderen Flächeninhalten berechnen und nicht zu x-beliebigen Merkmalen.

Später brauche ich auch noch eine Datenstruktur der Art list<Merkmal *> in dem dann verschiedene Merkmale drinstehen.

Kann man das in C++ nicht über eine abstrakte Klasse realisieren ?
Ich meine mich zu erinnern, dass es in Java beispielsweise geht (solange man nicht mit "new()" ein Objekt der abstrakten Klasse erzeugt.).

Wie komm ich aus dem Problem raus ?

Artchi

getDistance(Flächeninhalt f) und getDistance(Merkmal m) sind zwei verschiedene Methoden, nennt sich Überladung. Weil sie sich in den Parameter-TYPEN unterscheiden. Du muß aber definitiv getDistance(Merkmal m) implementieren, was du in deiner Klasse Flächeninhalt nicht gemacht hast.

Doch ich habe ja im 2. Versuch

virtual float getDistance(Merkmal m) implementiert, aber das gab ne Fehlermeldung weil Merkmal abstrakt ist.

virtuell Realisticer

Selenia schrieb:

Doch ich habe ja im 2. Versuch

virtual float getDistance(Merkmal m) implementiert, aber das gab ne Fehlermeldung weil Merkmal abstrakt ist.

Du kannst aber ein Merkmal* nutzen.

mfg
v R

AHA .
Dann ist das also der Trick. Danke schön !

Wenn Du keinen Bock auf Zeiger dereferenzieren hast, kannst Du auch Referenzen benutzen. Außerdem sollte man von dem Feature Gebrauch machen, es per Compiler verbieten zu lassen, Objekt-Zustände dort zu verändern, wo es nicht gewollt ist. Was ich meine, sind die (bei Java und den meisten anderen Sprachen fehlenden) Möglichkeiten, Argumente und/oder Methoden als const zu deklarieren. Hier ein Beispiel:

#include <iostream>

using namespace std;

class Merkmal
{
public:
	Merkmal(float value) : m_value(value) {}

	virtual float getDistance(const Merkmal &m) const = 0;

	float getValue() const { return m_value; }
	void setValue(float value) { m_value = value; } 

protected:
	float m_value;
};

class Foo : public Merkmal
{
public:
	Foo(float value) : Merkmal(value) {}

	virtual float getDistance(const Merkmal &m) const
	{
		return m.getValue() - m_value;
	}
};

class Bar : public Merkmal
{
public:
	Bar(float value) : Merkmal(value) {}

	virtual float getDistance(const Merkmal &m) const
	{
		//Compiler verbietet Veränderung des Merkmal-Zustands! ... (const Merkmal &m) ...
		//m.setValue(4711);

		//Compiler verbietet Veränderung des eigenen Zustands! ... (...) const 
		//m_value = 4711;

		return m.getValue() - m_value*m_value; 
	}
};

int main()
{
	Foo f = Foo(12);
	Bar b = Bar(2);

	cout << f.getDistance(b) << endl;
	cout << b.getDistance(f) << endl;

	cin.get();
}

Ja ok ist eh const. Für die Fragen versuche ich immer alles nicht relevante aus dem Code rauszulassen, aber trotzdem danke .

Polymorphie &amp; abstrakte Klassen

Polymorphie & abstrakte Klassen