Polymorphismus in C++ Warum funktioniert das nicht?

Question

class Base { 
    public: 
    virtual void f(); 
    void f(int); 
    virtual ~Base(); 
}; 

class Derived : public Base { 
public: 
    void f(); 
}; 

int main() 
{ 
    Derived *ptr = new Derived; 
    ptr->f(1); 
    delete ptr; 
    return 0; 
} 

ptr-> f (1); zeigt den folgenden Fehler: "zu viele Argumente in Funktionsaufruf".

Warum ist das nicht möglich? ist nicht abgeleitet alle Funktionen geerbt geerbt und ist frei, eine von ihnen zu verwenden? Ich könnte es explizit nennen und es würde funktionieren, aber warum ist das nicht erlaubt?

Answer 1

Was Sie sehen, heißt versteckt.

Wenn Sie die Funktion void f() in der Derived Klasse überschreiben, können Sie verstecken alle anderen Varianten der f Funktion in der Base Klasse.

Sie können dieses Problem lösen mit dem using Stichwort:

class Derived : public Base { 
public: 
    using Base::f; // Pull all `f` symbols from the base class into the scope of this class 

    void f() override; // Override the non-argument version 
}; 

Answer 2

Wie @Some Programming Geck erwähnt: es wegen Verstecken ist.

Um Versteck in relativ einfacher Sprache

Inheritance sollte Base Klassenvariablen/Funktionen in Derived Klasse bringen zu verstehen.

Aber am 1. Bedingung: „Wenn es nicht bereits in Abgeleitete Klasse“

Seit f() ist bereits in Derived, macht es keinen Sinn macht aus Compiler Perspektive Base Klasse zu suchen.

, dass der genaue Grund ist, warum Sie zu Umfang müssen klären, während Aufruf dieser Funktion

void main() 
    { 
     Derived *ptr = new Derived; 
     ptr->Base::f(1); 
     delete ptr; 
    } 

Answer 3

für Zeit Angenommen wird, dass Derivedvoid Base::f(int); den Zugriff auf die Funktion haben, zu tun. Dann wird es ein Fall von function overloading sein. Aber dies ist ungültig Fall von function overloading, da eine Funktion f(int); ist in Base und andere Funktion f(); in Abgeleitet ist. Function Overloading passiert in einer einzigen Klasse. Function Overriding passiert über Klassen. Das von Ihnen gepostete Beispiel ist Name Hiding in Inheritance

Answer 4

"Derived * ptr" Diese Definition erlaubt nur "ptr" Zugriff auf alle Mitgliedsfunktionen, die über Abgeleitete Klasse oder seine Kindklasse definiert sind. Aber es wird Ihnen nicht erlauben, auf die Mitgliedsfunktionen zuzugreifen, die aufgrund der Vererbung in die abgeleitete Klasse kommen.

Wenn u Basisklassenversion der Funktion „f“ zugreifen möchten, dann „Basis * ptr“ verwenden und es wird die richtige Version der Funktion automatisch wählen, wie gezeigt :)

class Base { 
    public: 
     virtual void f() 
     { 
      cout<<"Here 2"<<endl; 
     } 
     void f(int x) 
     { 
      cout<<"Here 1"<<endl; 
     } 
     virtual ~Base() {} 
}; 

class Derived : public Base { 
    public: 
     void f() 
     { 
      cout<<"Here 3"<<endl; 
     } 
     virtual ~Derived() {} 
}; 

int main() 
{ 
    Base *ptr = new Derived; 
    ptr->f(1); 
    delete ptr; 
    return 0; 
} 

Ausgang ist hier 1