Ich würde gerne wissen, wie ich die folgende Situation ohne fleissiges Copy&Paste lösen kann:
Ich habe eine Basisklasse für Dokumente, die von CDocument abgeleitet ist. In dieser Klasse bzw. der jeweils betroffenen abgeleiteten Klasse werden u.a. die Druckbefehle empfangen.

Und ich habe eine Basisklasse für Recordsets, die von CRecordset abgeleitet ist. In der bzw. der jeweils betroffenen abgeleiteten Klasse wird die Druckausgabe übernommen.

Jedes abgeleitete Dokument hat eine GetDaten Funktion, die immer die passende Recordsetklasse zurück gibt.

Also:
CKundenDoc: CKundenSet& GetDaten()
CFirmenDoc: CFirmenSet& GetDaten()
usw.
Könnte man denn in der Basisklasse ein GetDaten einbauen, was immer das richtige Recordset zurückgibt?

Könnte man denn in der Basisklasse ein GetDaten einbauen, was immer das richtige Recordset zurückgibt?

Wenn die beiden ne gemeinsame Basisklasse haben, könntest Du die als Rückabetyp angeben.

virtual CBasisSet& GetDaten();

in KundenDoc:

virtual CKundenSet& GetDaten();

in FirmenDoc:

virtual CFirmenSet& GetDaten();

und der nimmt dann immer die Funktion der abgeleiteten Klasse?
Die Druckfunktion in der Basisklasse ist nämlich momentan nur ein Dummy, der später mal so aussehen wird:

virtual void Drucke() = 0;

virtual CBasisSet& GetDaten() = 0;

In KundenDoc.h

CKundenSet& GetDaten();

error C2555: 'CKundenDoc' von 'CKundenDoc::GetDaten': Neue Version der virtuellen Funktion unterscheidet sich von 'CBasisDoc::GetDaten' 
nur hinsichtlich des Ergebnistyps oder der Aufrufkonvention

Naja, und dann noch die üblichen Folgefehler...

error C2259: "CKundenDoc" : Instanz von abstrakter Klasse kann auf Grund nachfolgender Elemente nicht erstellt werden:
warning C4259: 'class CBasisSet &__thiscall CBasisDoc::GetDaten(void)' : Rein virtuelle Funktion wurde nicht definiert

Geht das vielleicht nur mit Zeigern? Dann hätte ich viel umzubauen.

Kann man also sowas machen:
in BasisDoc:

virtual CBasisSet& GetDaten();

in KundenDoc:

virtual CKundenSet& GetDaten();

in FirmenDoc:

virtual CFirmenSet& GetDaten();

[/cpp]

Das sollte AFAIK nicht gehen dürfen. Die virtuellen Methoden müssen beim überschreieben in den abgeleiteten Klassen exakt so aussehen wie in der Basisklasse ...

Edit: Beachte camper's Post

Das sollte AFAIK nicht gehen dürfen. Die virtuellen Methoden müssen beim überschreieben in den abgeleiteten Klassen exakt so aussehen wie in der Basisklasse ...

Hatte Michael nicht gesagt, dass das geht? Oder hab ich da nur was rausgelesen, was ich lesen wollte?

Edit: Beachte camper's Post

Den da? http://www.c-plusplus.net/forum/viewtopic-var-t-is-151830.html
Da hab ich den Zusammenhang noch nicht erkannt, aber ich denk nochmal drüber nach.

Eventuell mache ich jetzt einfach eine GetBasisSet. Die heißt anders und dann sollte es gehen.

Bsp:

class X {
public:
	virtual X& foo() = 0;
};

class Y : public X {
public:
	virtual Y& foo();
};

class Z : public Y {
public:
	virtual Z& foo();
};

Das ist völlig legal, für ältere Compiler wie z.B. den VC 6.0 allerdings nicht verdaubar.

class X {
public:
    X& foo() { return foo_impl(); }
protected:
    virtual X& foo_impl() = 0;
};

class Y : public X {
public:
    Y& foo() { return static_cast<Y&>(foo_impl()); }
protected:
    virtual X& foo_impl();
};

class Z : public Y {
public:
    Z& foo() { return static_cast<Z&>(foo_impl()); }
protected:
    virtual X& foo_impl();
};

und schon sind wir nicht mehr auf compilerunterstützung für kovariante returntypen angewiesen. tatsächlich können wir sogar noch mahr tun. compilergestützte kovarianz beschränkt sich ja auf referenzen und pointer. wir könnten hier z.b. auch ohne weiteres smart pointer einsetzen (sofern sie untereinander konvertierbar sind).

class X {
public:
    X& foo() { return foo_impl(); }
protected:
    virtual X& foo_impl() = 0;
};

class Y : public X {
public:
    Y& foo() { return static_cast<Y&>(foo_impl()); }
protected:
    virtual X& foo_impl();
};

class Z : public Y {
public:
    Z& foo() { return static_cast<Z&>(foo_impl()); }
protected:
    virtual X& foo_impl();
};

*STAUN* *FINDSCHÖN*

*STAUN* *FINDSCHÖN*

In C++ Kreisen firmiert diese Denkschule unter dem Begriff "non-virtual interface idiom" (bzw. pattern) kurz NVI. Gut erklärt wird NVI z.B. in Sutters und Alexandrescus "C++ Coding Standards".

Das ist völlig legal, für ältere Compiler wie z.B. den VC 6.0 allerdings nicht verdaubar.

Okay, da war der Haken...

Das mit der GetBasisSet funktioniert aber prima.
Über das Beispiel eben von camper muss ich wohl nochmal in Ruhe nachdenken.
Bei so arg theoretischen Sachen habe ich irgendwie Verständnisschwierigkeiten.