ich habe überhaupt gar keine Ahnung, warum folgender Code nicht compiliert. Habs mit VC 8 und g++ versucht, beide liefern denselben Fehler ("'B::Init' : function does not take 1 arguments").

Warum nur??? Ich dachte, das sei einfach nur Vererbung. Noch einfacher geht's ja fast nicht...

#include <string>

class A
{
public:
    void Init(const std::string& s){};
    virtual void Init(const std::string& s, int a){};
};

class B : public A
{
public:
    virtual void Init(const std::string& s, int a){};
};

int main()
{
    B b;
    b.Init("Hallo!");
    return 0;
}

Tausend Dank,
Felix

#include <string>

class A
{
public:
    void Init(const std::string& s){};
    virtual void Init(const std::string& s, int a){};
};

class B : public A
{
public:
    virtual void Init(const std::string& s, int a){};
};

int main()
{
    B b;
    b.Init("Hallo!", 1);
    return 0;
}

steht sogar im funktionskopf. hat nichts mit vererbung zu tuen
ich verordne dir als strafe 15 minuten tutorial lesn xD

int main()
{
    B b;
    b.A::Init("Hallo!");
    return 0;
}

2. durch Deklaration einer enstprechenden Überladung in B:

class B : public A
{
public:
    void Init(const std::string& s){ return A::Init(s); }
    virtual void Init(const std::string& s, int a){}
};

3. mittels using-Deklaration:

class B : public A
{
public:
    using A::Init;
    virtual void Init(const std::string& s, int a){}
};

Eine Deklaration verdeckt jede andere Deklaration gleichen Namens in einem äußeren Scope bzw. einer Basisklasse.

Ist das mit NAME ernst gemeint?!?! Oder Signatur?? Wobei -- da ich den Fehler bekomme, ist's wohl der Name...

Das finde ich aber sehr sehr verwirrend. Methoden sind normalerweise bei C++/Java/C#/... durch die Signatur (also Name UND Parameterliste) und nicht den Namen allein unterschieden.

Cheers,
Felix

Das finde ich aber sehr sehr verwirrend. Methoden sind normalerweise bei C++/Java/C#/... durch die Signatur (also Name UND Parameterliste) und nicht den Namen allein unterschieden.

Das ist auch richtig. Worauf du dich beziehst ist die Überladungsauflösung, wenn eine Funktion mehrere Überladungen hat. Bevor diese aber stattfinden kann, müssen aber erst einmal alle Überladungen, die in Frage kommen, gefunden werden. Dieser Vorgang (name lookup) berücksichtigt an sich nur den Namen.

Also das wäre mir auch neu, das der Name verdeckt wird. Ich müsste das für C++ auch noch mal speziell ausprobieren (meine tägliche Java-Arbeit sagt mir, das der Name nicht verdeckt wird!).

Weil die Funktion nur überschrieben wird? Das hat mich auch etwas unsicher gemacht, aber der Standard macht da keinen Unterschied. Eine große Rolle dürfte das kaum spielen, denn in der Regel werden virtuelle Funktionen wohl nicht überladen werden (oder man weicht auf des Template Pattern aus). D.h. Variante 4:

class A
{
public:
    void Init(const std::string& s){};
    void Init(const std::string& s, int a) { return Init_impl(s,a); }
private:
    virtual void Init_impl(const std::string& s, int a){};
};

class B : public A
{
private:
    virtual void Init_impl(const std::string& s, int a){};
};

The declaration of a member in a derived class (clause 10) hides the declaration of a member of
a base class of the same name; see 10.2.