Frage zu Überladenen virtueller Funktionen

Kurz das Problem als Beispiel.

class Base
{
public:
 virtual void serialize(ostream &out);
 virtual void serialize(ostream &out, bool child);
};

class Wichtig : public Base
{
public:
 virtual void serialize(ostream &out);
};

Jetzt mahnt mich der Compiler an das die zweite Funktion in der Klasse base von der ersten Funktion in der Klasse Wichtig versteckt wird. (hidden)
Compelieren lässt sich das und funktioniert auch. (Beide Funktionen über Klase Wichtig aufzurufen)

Jetzt die Frage:
Ist das ein Fehler vom Code, eine Überflüssige Meldung vom Compier oder nur ein schlechter Still, worauf mich der compiler aufmerksam machen will.

Lichtlein

Beispiel aus dem Standard (Kapitel 13.2):

class B {
public :
 int f ( int );
};
class D : public B {
public :
 int f ( char *);
};

Hier wird B::f(int) von D::f(char*) verdeckt, nicht überladen.

Der Compiler warnt dich, weil das eventuell nicht das Verhalten ist was du wünscht und du die Funktion serialize(ostream &, bool) von einem Wichtig-Objekt aus nicht mehr ohne weiteres aufrufen kannst.

Danke schön
Lichtlein

Wenn du nur sagst, dass du etwas nicht verstehst, kann ich dir auch nicht weiterhelfen.

Jetzt mahnt mich der Compiler an das die zweite Funktion in der Klasse base von der ersten Funktion in der Klasse Wichtig versteckt wird. (hidden)
Compelieren lässt sich das und funktioniert auch. (Beide Funktionen über Klase Wichtig aufzurufen)

Das ist ein bisschen unpräzise.
Untersuchen wir einfach mal alle Möglichekeiten eines direkten Funktionsaufrufes:

Wichtig x( ... );
Base& y = x;

x.serialize(cout); // ok
x.serialize(cout, true); // Fehler: diese Überladung wird verdeckt

y.serialize(cout); // ok
y.serialize(cout, true); // ok

x.Wichtig::serialize(cout, true); // ok

Sind virtuelle Funktionen im Spiel, werden Aufrufe typischerweise über das Interface der Basisklasse ausgeführt, damit spielt die Verdeckung dann keine Rolle.
Die allgemein empfohlene Abhilfe besteht in einer entsprechenden using Deklaration:

class Wichtig : public Base
{
public:
 using Base::serialize; // damit werden alle Deklaration der aus Base geerbten serialize Funktionen in den Scope der Klasse Wichtig injiziert
 virtual void serialize(ostream &out);
};

Aber bei den Virtuellen Funktionen nicht mehr.

Der Compiler muss ja für jede Funktion in den Sprungtabellen einen Eintrag machen.

(vtable) fuer Klasse Base
{func0] Base::~Base()
[func1] Base::serialize(ostream &Out)
[func2] Base::serialize(ostream &Out, bool Child)
[func3] ....

Nun macht er die vtable fuer Klasse Wichtig

(vtable) fuer Wichtig
{func0] Wichtig::~Wichtig()
[func1] Wichtig::serialize(ostream &Out)
[func2] Base::serialize(ostream &Out, bool Child)
[func3] ....

Findet der Compiler im Source die Stelle

serialize(cout);

und dann

serialize(cout, true);

kann er sie zu 100% richtig zuordnen. Also bedarf es keiner Warnung.

Ich kann mir aber denken das ausgehend von Deinen Beispiel, wo die Warnung angebracht ist, nicht noch einen Sonderregelung/Sonderüberprüfungen für Virtuelle/Überlade/Vererbte Funktionen erdacht worden ist, sondern der Compiler einfach eine Warnung schmeißt obwohl hier immer zu 100% Richtig aufgelöst werden kann.

Lichtlein

Oh danke, ich habe das jetzt selber ausprobiert.
Genau wie du geschrieben hast.

Habe dann noch mal meine Sourcen überflogen und die Stellen gesucht wo der Compiler nur eine Warnung gebracht hatte. (Waren etwa 10) Wie es der zufall will wurde immer nur die Funktion aufgerufen die auch virtual vererbt worden war.
Und die andere Funktion wurde nur aus der base Klasse benutzt. Wurde ich dadurch auf die falsche Fährte geführt.

Übrigens, das mit den using ist eine gute idee. Denke nie dran das man auch funktionsnamen damit aufsetzen kann.

Lichtlein