class C {
public:
  virtual void Foo();
  void Foo(int);
  void Foo(double);
};

class D : public C {
public:
  void Foo(int);  //verdeckt C::Foo(int) und C::Foo(double)
  using C::Foo; //macht die beiden wieder sichtbar
};

Der Grund ist, dass der Compiler, sobald er einen Namen sieht, immer erst im umgebenden Namespace nachschaut, dann in dessen umgebenden Namespace und so weiter, bis er einen entsprechenden Namen findet. Ist ein (oder mehrere) Name gefunden, wird nicht weiter gesucht und ueberprueft, welcher der gefundenen Namen am Besten zum Aufruf passt, und danach, ob der Zugriff verfuegbar ist (public etc).

Laesst man in meinem Beispiel das using weg und ruft Foo fuer ein D auf, findet er D::Foo(int) und hoert sofort auf zu suchen. Dann versucht er, den uebergebenen Parameter (egal was fuer einer das ist, oder obs mehr als einer ist) zum int zu machen.

Ein aehnliches Problem ist folgendes:

class C {
  Foo(double);
public:
  Foo(float);
};

int main() {
  C c;
  c.Foo(23.56); //Error: Foo(double) is private
  c.Foo(23); //Error: ambigue overload of Foo()
}

Man koennte denken, dass ganz klar beidemale Foo(float) aufgerufen werden muss, da Foo(double) ja private ist, aber da der Compiler erst nach der Signatur guckt, findet er, dass Foo(double) ein perfekter Match fuer 23.56 ist und findet danach erst raus, dass das private ist und damit nicht zugaenglich. bei Foo(23) stellt er fest, dass die Konvertierung von int nach float und double gleich gut ist und kann sich nicht entscheiden - die Zugru=iffsrechte zieht er garnicht erst in Betracht.

Man koennte denken, dass ganz klar beidemale Foo(float) aufgerufen werden muss, da Foo(double) ja private ist, aber da der Compiler erst nach der Signatur guckt, findet er, dass Foo(double) ein perfekter Match fuer 23.56 ist und findet danach erst raus, dass das private ist und damit nicht zugaenglich. bei Foo(23) stellt er fest, dass die Konvertierung von int nach float und double gleich gut ist und kann sich nicht entscheiden - die Zugru=iffsrechte zieht er garnicht erst in Betracht.

Ganz schön dumm, so ein C++-Compiler

Ganz schön dumm, so ein C++-Compiler

Jein. Stell dir vor er machts anders und du wechselst irgendwann in einer Klasse die Zugriffsrechte einer Funktion. Das Programm haette sofort eine voellig andere Aussage weil eine andere Funktion aufgerufen wuerde - nur durch die Aenderung der Zugriffsrechte.

Badestrand schrieb:

Ganz schön dumm, so ein C++-Compiler

Jein. Stell dir vor er machts anders und du wechselst irgendwann in einer Klasse die Zugriffsrechte einer Funktion. Das Programm haette sofort eine voellig andere Aussage weil eine andere Funktion aufgerufen wuerde - nur durch die Aenderung der Zugriffsrechte.

Das ist doch jetzt auch schon so, nur eben nicht in dem von Dir beschriebenen Spezialfall.
EDIT: Alles Quatsch.

Der Name jeder public/protected Funktion der Basisklasse ist auch in abgeleiteten Klassen grundsaetzlich zugaenglich. Solltest du allerdings eine Funktion der Basisklasse in der abgeleiteten Klasse ueberschreiben, verdeckst du damit alle weiteren Funktionen gleichen Namens in der Basisklasse:

class C {
public:
  virtual void Foo();
  void Foo(int);
  void Foo(double);
};

class D : public C {
public:
  void Foo(int);  //verdeckt C::Foo(int) und C::Foo(double)
  using C::Foo; //macht die beiden wieder sichtbar
};

fast:
die deklaration void Foo(int) verdeckt alle Foos aus C, und die using deklaration in diesem beispiel macht nur C::Foo(double) und C::Foo() wieder sichtbar. ( C::Foo(int) wird immer noch von D::Foo(int) verdeckt)

damit der code zu deiner beschreibung passt:

class D : public C {
public:
  void Foo();  //überschreibt C::Foo(), verdeckt C::Foo(int) und C::Foo(double)
  using C::Foo; //macht C::Foo(int) und C::Foo(double) wieder sichtbar.
};