Wird die Freund-Funktion hier vererbt?

Question

Die Methode fun() in der Klasse Derived ist privat. Wenn wir die Funktion ptr->fun() durch Laufzeitpolymorphismus aufrufen, wird sie ausgeführt. Dies verletzt jedoch die Kapselungseigenschaft der abgeleiteten Klasse.

#include<iostream> 
using namespace std; 

class Derived; 

class Base { 
private: 
    virtual void fun() { cout << "Base Fun"; } 
friend int main(); 
}; 

class Derived: public Base { 
private: 
    void fun() { cout << "Derived Fun"; } 
}; 

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

Kann jemand bitte erklären, was passiert ist?

Answer 1

Zu allererst Ihr Derived::fun() ist auch virtual, denn wenn eine Funktion in einer abgeleiteten Klasse die gleiche Erklärung wie eine virtuelle Funktion in der Basisklasse hat, automatisch die Funktion in abgeleiteten Klasse virtual bekommt, auch wenn diese nicht explizit waren angegeben.

Zweitens ist es völlig in Ordnung, auf private virtuelle Funktionen über öffentliche Zwischenfunktionen aus der Basisklasse zuzugreifen, siehe z. B. this answer und seine Links, insbesondere Virtuality by Herb Sutter. Ein Codebeispiel sein könnte wie

#include<iostream> 
using namespace std; 

class Derived; 

class Base { 
private: 
    virtual void fun() { cout << "Base Fun"; } 
public: 
    void funInt() { fun(); } 
}; 

class Derived: public Base { 
private: 
    virtual void fun() { cout << "Derived Fun"; } 
}; 

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

Also, was in Ihrem Fall geschieht, denke ich, ist eine ähnliche Situation: der main darf ptr->fun() zugreifen, aber aufgrund Virtua diese fun() geschieht Derived::fun() zu sein.

UPD: auf einen Kommentar erweitern

Aber nicht dieser Ton ein wenig alarmierend ..Ich meine, alle Funktionen , die von der Basisklasse ableiten, werden ihre private Mitglieder zugänglich den Freund Funktionen der Basisklasse haben

Nein, nicht alle Funktionen von Derived werden den Freunden zugänglich sein, Base, aber nur diejenigen, die über Base Zeiger erreichbar sind. Zum Beispiel:

int main() { 
    Derived *ptr = new Derived; 
    Base* baseptr = ptr; 
    baseptr->fun(); // ok, calls Derived::fun() 
    baseptr->foo(); // error, no such function in Base 
    ptr->foo(); // error, foo is private 
    return 0; 
} 

anzumerken, dass virtual Funktion absichtlich erweiterbare und jede Überschreibung von virtual Funktion in Derived bedeutet, dass die Funktion kann über Base genannt werden:

class Base { 
    virtual void fun(); 
    friend int main(); 
} 
class Derived: public Base { 
    virtual void fun(); 
    virtual void foo(); 
    void bar(); 
} 

nur Derived::fun() können vom Haupt zugegriffen werden Zeiger; Dies ist der Hauptzweck von virtual Funktionen. Wenn Derived seine vorrangige Funktion private macht, sollte es immer noch bewusst sein, dass die Funktion über Base Zeiger zugegriffen werden kann, denn das ist die Grundidee hinter den virtual Funktionen.

Answer 2

Dies passiert, weil Sie fun als virtuell deklariert haben. Zur Laufzeit, wenn die vtable durchsucht wird, findet sie den Eintrag für Derived::fun() und springt damit zur Adresse.

Die Freund-Funktionen werden jedoch nicht geerbt, Sie können dies überprüfen.

class Base { 
private: 
    virtual void fun() { cout << "Base Fun"; } 
    friend int main(); 
    int z = 20; 
}; 

class Derived : public Base { 
private: 
    void fun() { cout << "Derived Fun"; } 
    int m = 10; 
}; 

int main() 
{ 
    Base *ptr = new Derived; 
    ptr->z = 10; //Accepted 
    ptr->m = 5; //error 
    return 0; 
} 

Hier Privat Mitglied Derivedm ist zur Haupt nicht zugänglich.

Answer 3

Friend Funktionen nehmen niemals an der Vererbung teil.

Was passiert hier?
Wenn virtuelle Methode in Base Klasse definiert ist, ist eine virtuelle Tabelle enthält createdwhich Adresse fun Methode der Base Klasse. Und da, Derived Klasse erbt, enthält die VTABLE auch die Adresse Derived Klasse fun Methode. Nun, da main die Friend-Funktion der Klasse Base ist, ermöglicht der Compiler den Zugriff seiner Mitglieder auf die Methode main unabhängig von ihrem Zugriffsspezifizierer. Daher erhält main die Adresse Derived::fun und Derived Klasse fun wird zur Laufzeit aufgerufen.