class SuperClass
{
public:
	SuperClass(void){};
	~SuperClass(void){};
	virtual bool isEqual(SuperClass s) = 0;
};

Von dieser Klasse leite ich jetzt eine zweite Klasse ab, die die Schnittstelle implementieren soll:

class ClassA : public SuperClass
{
public:
	ClassA(void){};
	~ClassA(void){};
	bool isEqual(ClassA c)
	{
		return true;
	}
};

Der Compiler sagt mir:

'ClassA': Instanz von abstrakter Klasse kann nicht erstellt werden aufgrund folgender Member:
"bool SuperClass::isEqual(SuperClass)": ist abstrakt

Offensichtlich stört er sich am Argument der isEqual-Methode, wenn ich das rausnehme, gibt der Compiler sein OK.

Was ich möchte, ist die Implementierung einer Vergleichsoperation zwischen zwei Objekten zu erzwingen.

Kann mir jemand weiterhelfen?

Gruß, Tim.

das sind ja auch nicht "dieselben" Funktionen:

Tim_ schrieb:

...

bool isEqual(SuperClass s) = 0;
	bool isEqual(ClassA c)

...

... weil sie nicht dieselbe Signatur haben (unterschiedliche Parameter).
Du wirst übel Probleme mit Objektzerlegung haben, wenn Du das so machen möchtest.
Außerdem dürfte Dir der Call-per-Value machen, weil Du eine Kopie übergibst.
Und schließlich läufst Du da wohl in "double-dispatching-Probleme" rein, wenn Du das mit Referenzen/Pointern machen möchtest.

struct Base {
   virtual bool isEqual(Base const*) = 0;
};

struct D1 = Base {
   bool isEqual(Base const*);
};

struct D2 = Base {
   bool isEqual(Base const*);
};

int main() {
   D1 d1;
   D2 d2;
   d1.isEqual(&d2); // Woher weiß D1::isEqual, welcher Typ sein Parameter ist ?

Kleine Randfrage: Hast Du bislang Java programmiert ?

Gruß,

Simon2.

Kleine Randfrage: Hast Du bislang Java programmiert ?

Sowas (kovariante Argumenttypen) geht auch in Java nicht. Die abgeleitete Klasse muss mindestens genauso viel können wie die Methode der Oberklasse, also muss sie auch Objekte der Oberklasse als Argument entgegennehmen können. Möglicherweise mehr, wenn man will und falls es noch eine SuperSuperClass gibt.

isEqual(? extends SuperClass)

Müsste gehen, wenn ich mich nicht irre.

Simon2 schrieb:

Kleine Randfrage: Hast Du bislang Java programmiert ?

Sowas (kovariante Argumenttypen) geht auch in Java nicht. Die abgeleitete Klasse muss mindestens genauso viel können wie die Methode der Oberklasse, also muss sie auch Objekte der Oberklasse als Argument entgegennehmen können. Möglicherweise mehr, wenn man will und falls es noch eine SuperSuperClass gibt.

Das ist dann allerdings Kontravarianz

Das ist dann allerdings Kontravarianz

Richtig. Ich verstehe den Smiley nicht.

@Konrad Rudolph:
Keine Ahnung, was bedeutet das, und wie sieht das syntaktisch vollständig aus? Ist das nicht für generische Sachen? Meine Java-Kenntnisse sind etwas veraltet.

Keine Ahnung, was bedeutet das, und wie sieht das syntaktisch vollständig aus?

Das ist vollständig. Java implementiert explizite Ko- und Kontravarianz von generischen Parametern über die von mir verwendete Syntax. Womit ich nur ausdrücken wollte, dass Deine Aussage:

Bashar schrieb:

Sowas (kovariante Argumenttypen) geht auch in Java nicht.

nicht mehr korrekt ist.

Meine Java-Kenntnisse sind etwas veraltet.

Nun gut, das kann Java auch noch nicht so lange.

/EDIT: Hmm, die Syntax ist so wohl doch nicht ganz vollständig. Keine Ahnung, wie man das genau machen müsste. Hab das erst sehr selten verwendet.

Ich verstehe den Smiley nicht.

Fall von unbewusster Imitation. Stell es dir als Metadaten vor, ohne eigenen Sinn in sich.

Servus.
Ich habe eine Klasse mit einer Schnittstellenmethode "isEqual()":

class SuperClass
{
public:
	SuperClass(void){};
	~SuperClass(void){};
	virtual bool isEqual(SuperClass s) = 0;
};

Das kann schonmal deswegen nicht gehen weil SuperClass abstrakt ist, und man daher keine SuperClass Instanzen erstellen kann. Die Übergabe einer SuperClass als Parameter (by value) geht daher schonmal überhaupt nicht.

Und vermutlich weil die Sache so verflixt danach aussieht als ob hier "isEqual(SuperClass* s)" statt "isEqual(SuperClass s)" gemeint war dann die Frage ob du vorher Java programmiert hast (weil dort die Schreibweise "isEqual(SuperClass s)" korrekt wäre).

...
Und vermutlich weil die Sache so verflixt danach aussieht als ob hier "isEqual(SuperClass* s)" statt "isEqual(SuperClass s)" gemeint war dann die Frage ob du vorher Java programmiert hast (weil dort die Schreibweise "isEqual(SuperClass s)" korrekt wäre).

Eben.

danke für eure zahlreichen Antworten. Tatsächlich komme ich ursprünglich aus der Java-Welt. So etwas wie Operatorenüberladung ist mir neu, aber im Grunde das, was ich in diesem Zusammenhang suche.
Ich würde nur gern irgendwie erzwingen, dass der Vergleichsoperator von abgeleiteten Klassen überladen wird.
Ich nehme an, auch

virtual bool operator ==(SuperClass s) = 0;

bzw.

virtual bool operator ==(SuperClass* pS) = 0;

wird aus den genannten Gründen nicht funktionieren.

Nochmal zur Erklärung, was ich eigentlich modellieren will:
Ich habe eine Schnittstellenklasse "ParameterSet", welche unter anderem die Methoden "virtual void setStandardParameter() = 0;" und "virtual int getChecksum() = 0;" vorgibt, die abgeleitete Klassen implementieren müssen. Hier würde ich auch gern eine (virtuelle) Vergleichsoperation unterbringen.
Vielleicht habt ihr eine Idee.

Gruß, Tim.

Ok, das verstehe ich soweit.
D.h. es ist grundsätzlich nicht möglich, eine Schnittstellenfunktion zu definieren, in deren Argumenten ein Bezug zur abgeleiteten Klasse hergestellt wird?

Ein klares JEIN Schau dir mal folgendes an:

class AbstractSuperClass 
{
public: 
  virtual void setStandardParameter() = 0;
  virtual int getChecksum() = 0;
};

template <class Derived>
class SpecificSuperClass : public AbstractSuperClass
{
public:
  virtual bool isEqual(Derived const& other) = 0;
};

class Concreteclass : public SpecificSuperClass<Concreteclass>
{
public:
  //hier muss isEqual(Concreteclass const&) definiert werden
};

Die Art, aus der Basisklasse ein template zu machen das abhängig ist von der abgeleiteten Klasse, nennt sich "Curiously Recurring Template Pattern" - für mehr Informationen darüber gibts bei google vermutlich ne Menge Links.

Ein klares JEIN Schau dir mal folgendes an:

class AbstractSuperClass 
{
public: 
  virtual void setStandardParameter() = 0;
  virtual int getChecksum() = 0;
};

template <class Derived>
class SpecificSuperClass : public AbstractSuperClass
{
public:
  virtual bool isEqual(Derived const& other) = 0;
};

class Concreteclass : public SpecificSuperClass<Concreteclass>
{
public:
  //hier muss isEqual(Concreteclass const&) definiert werden
};

Ok, mit virtuellen Template-Methoden hatte ich schon erfolglos experimentiert aber das Template über die ganze Klasse zu setzen, ist mir bisher noch nicht in den Sinn gekommen.
Danke für den Tipp.

class Object
{
public:
    virtual bool isEqual(Object const* other) const = 0;
};

Das hat den Vorteil dass man 2 "Objekte" vergleichen kann, auch ohne zu wissen ob sie überhaupt vom gleichen Typ sind. D.h. ich kann einen String mit einem Rechteck vergleichen (und würde einfach nur "false" rausbekommen).
Was oft sehr praktisch ist.
Oder ich kann rausbekommen dass 2 Objekte gleich sind, ohne wissen zu müssen von welchem Typ sie nun sind.

Das hat den Vorteil dass man 2 "Objekte" vergleichen kann, auch ohne zu wissen ob sie überhaupt vom gleichen Typ sind. D.h. ich kann einen String mit einem Rechteck vergleichen (und würde einfach nur "false" rausbekommen).
Was oft sehr praktisch ist.

Wann ist das praktisch?

Sicher, in gewissen Vererbungshierarchien mag ein solches Wissen notwendig sein (Composite Pattern …). Aber ich sehe keine Situation, in der man Strings mit Rechtecken vergleichen muss.

...ich kann einen String mit einem Rechteck vergleichen (und würde einfach nur "false" rausbekommen)...

Nicht unbedingt ... das hängt doch ziemlich von der Art des Vergleichs ab.

Gruß,

Simon2.

/EDIT: Hmm, die Syntax ist so wohl doch nicht ganz vollständig. Keine Ahnung, wie man das genau machen müsste. Hab das erst sehr selten verwendet.

Bevor ich mich geschlagen gebe, würde ich trotz allem gerne noch wissen, wie das aussehen soll. Die ? extends foo Syntax hab ich bisher nur im Kontext von Generics gesehen, und ich bin mir nicht ganz sicher ob das das ist was wir hier suchen.

Konrad Rudolph schrieb:

/EDIT: Hmm, die Syntax ist so wohl doch nicht ganz vollständig. Keine Ahnung, wie man das genau machen müsste. Hab das erst sehr selten verwendet.

Bevor ich mich geschlagen gebe, würde ich trotz allem gerne noch wissen, wie das aussehen soll. Die ? extends foo Syntax hab ich bisher nur im Kontext von Generics gesehen, und ich bin mir nicht ganz sicher ob das das ist was wir hier suchen.

Ja, ich meinte es auch durchaus im Kontext von Generics. Wobei man hierfür die Template-Kontravarianz gar nicht braucht (hmm, fällt mir spät ein) – ich meinte eigentlich so etwas wie CRTP für Java, womit der erzielte Effekt erreicht würde. … bin gerade ein wenig konfus.

(Ich habe keine Ahnung, ob man sowas in Java überhaupt verwendet, aber in .NET macht man das.)

abstract class Base<T> {
    public abstract boolean isEqual(T other);
}

class Derived extends Base<Derived> {
    public boolean isEqual(Derived other) { return true; }
};