Basisklassenfunktion von abgeleiteter Klasse aus aufrufen

Hallo Leute,

also ich habe eine Basisklasse(A) von der ich eine Klasse(B) abgeleitet habe. Kann ich jetzt aus einer Methode von B heraus, eine Methode von A aufrufen? Natürlich, aber was wenn beide Methoden denselben Namen(und Parameter) haben?

Der Hintergrund ist dass beide Methoden Load() heißen sollen, wobei B::Load() A::Load aufruft und danach selber noch was lädt. Und ich hab keine Lust aus B::Load() so was wie B::LoadBasis() zu machen.

Z2

A::Load();

A::Load() und dann?

Z2

Wie, und dann? Das ist der Funktionsaufruf für die Load-Funktion aus der Klasse A. Den schreibt man in die Funktion B::Load() hinein. Was da sonst noch in die Funktion B::Load() hineinkommt, mußte du schon selbst wissen. Ich kann schließlich nicht hellsehen.

HumeSikkins

lumpinus schrieb:

A::Load() und dann?

Nix mehr. Das war es schon. Wenn du in B::Load() A::Load() aufrufen willst, dann tust du das einfach mit A::Load().

HumeSikkins

Viel zu spät

Mein Problem ist, dass B keine Instanz von A kennt.
Wenn ich in B::Load(), Load() schreibe will ich, dass die Methode aus der Parent-Klasse (also A) aufgerufen wird, und nicht dass sich die Methode selbst aufruft.
Wenn ich wollte, dass B::Load() sich selbst aufruft könnte ich ja auch explizit this->Load() schreiben.

CStoll

Du bist in Klasse B, da führt der Aufruf "Load()" zur Load-Methode von Klasse B. Um dem Compiler zu sagen, daß du eine andere willst, mußt du das auch angeben - dazu verwendest du das "A::Load()".

(und B kennt eine Instanz von A - sich selber ;))

Spacelord

lumpinus schrieb:

Mein Problem ist, dass B keine Instanz von A kennt.

Doch tut sie gaaaaaaanz sicher.B enthält ein anonymes Subobjekt vom Typ A.

Gruß Spacelord

Ich glaube ich wisst überhaupt nicht was ich will.
Deshalb Beispielcode:

class A {
public:
	void Load();
};

class B : public A {
public:
	void Load();
};

void A::Load() {
	//mach was
}

void B::Load() {
	//mach was
	/*
	Jetzt will ich die Load() Methode aus A aufrufen
	Wie geht das?
	So wie es jetzt da steht wird ja wohl B::Load() aufgerufen,
	d.h. die Methode ruft sich selbst auf
	*/
	Load(); 
}

CStoll

Wie dir schon mindestens zehnmal in diesem Thread geantwortet wurde:

void B::Load() {
    //mach was
    A::Load(); 
}

(vielleicht solltest du mal versuchen, die ankommenden Antworten auch zu LESEN ;))

ser1al

sag mal ehrlich, ließt du die antworten oder wartest du nur auf fertigen code?

das wurde hier schon 10mal gesagt: A::Load()

class A {
public:
    void Load();
};

class B : public A {
public:
    void Load();
};

void A::Load() {
    cout<<"A::Load";
}

void B::Load() {
    cout<<"B::Load";
    A::Load();
}

int main(int argc, char* argv[])
{
 B test;
 test.Load();
 getch();       return 0;
}

[Edit] argh zu spät

Das ist ja genial!!

Jetzt hab ichs verstanden, nur das Problem bleibt ja. Woher kennt B A ?

ser1al

lumpinus schrieb:

Das ist ja genial!!

Jetzt hab ichs verstanden, nur das Problem bleibt ja. Woher kennt B A ?

ließ am besten nochmal in deinem buch oder einem guten tutorial nochmal aufmerksam das thema der vererbung durch!

Wie schon erwähnt, es wurde sozusagen in B ein Subtyp der Klasse A erstellt! (einfacher kann ich es nicht erklären)

Hallo

lumpinus schrieb:

Woher kennt B A ?

B wird doch von A abgeleitet und daher kennt es auch die Funktionen von A.

chrische

In Tutorials und Büchern steht, dass B::Load() A::Load() überschreibt und A::Load() damit für B gestorben ist. Der this Zeiger zeigt ja auf B nur welcher Zeiger zeigt auf A? Keiner, denn es gibt ja keine Instanz von A.

Z2

Der this Zeiger zeigt auf A. Denn ein B ist ein A. Ist das wirklich so schwer zu kappieren?

CStoll

Doch: die Klasse B ist ja von A abgeleitet, deshalb gibt es irgendwo in ihrem Inneren noch einen A-Anteil - und dessen Elemente kannst du erreichen, indem du das A:: verwendest (auch wenn B sie überschrieben hat).

Ok, this zeigt auf A.
ist mit this->Load() dann A oder B gemeint??

Doch wohl B, sonst wäre das doch total sinnlos!!!

Ok,
anscheinend komm ich nicht dahinter. Dann schreib ich jetzt eben statt A::Load A::LoadBasis.