Überladene + virtuelle Methoden

Hallo,

ich habe folgendes Problem: Ich ahbe drei Klassen A, B, C, wobei B von A erbt und C von B. A definiert die virtuelle Methode foo(int), B die Methode foo() und C wiederum foo(int).

Wenn ich nun eine Instanz von C habe (über einen Zeiger von B), möchte ich gerne das foo(int) von C rufen. Wie kann ich das machen?

Vielleicht besser noch etwas Code zur Veranschaulichung:

#include <iostream>
using namespace ::std;

class A {
public :
	virtual void foo(int) {
		cout << "A::foo(int)" << endl;
	}
};

class B : virtual public A {
public :
	virtual void foo() {
		cout << "B::foo" << endl;
	}
};

class C : virtual public B {
public :
	virtual void foo(int) {
		cout << "C::foo(int)" << endl;
	}
};

int main() {
	B* b = new C();
	b->foo();
	b->A::foo(1); // ruft A::foo(int), aber nicht C::foo(int)
}

In der letzten Zeile von Main rufe ich b->A::foo(1), also das foo (int) von A. Ich möchte allerdings hier das foo von C rufen - wie bekomme ich das hin?

Grü0e,

RandomC++Noob

Hyde++ 0

B::foo() verdeckt A::foo(int), auch wenn es keinen Parameter erwartet.
Dadurch kennt die Klasse B keine Funktion foo(int).
Um das zu ändern, musst du in der Definition von B

using A::foo;

reinschreiben.

hustbaer

Na indem du es über einen A* aufrufst

int main() {
	B* b = new C();
	b->foo();
	//b->A::foo(1); // ruft A::foo(int), aber nicht C::foo(int)
	static_cast<A*>(b)->foo(1);
}