Come chiamare una funzione di class genitore dalla funzione di class derivata?

Come chiamo la funzione genitore da una class derivata usando C ++? Ad esempio, ho una class chiamata parent e una class chiamata child che è derivata dal parent. All’interno di ogni class c’è una funzione di print . Nella definizione della funzione di stampa del bambino, vorrei effettuare una chiamata alla funzione di stampa dei genitori. Come potrei fare questo?

Prenderò il rischio di affermare l’ovvio: si chiama la funzione, se è definita nella class base è automaticamente disponibile nella class derivata (a meno che non sia private ).

Se esiste una funzione con la stessa firma nella class derivata, è ansible disambigarla aggiungendo il nome della class base seguito da due punti base base_class::foo(...) . Si noti che a differenza di Java e C #, C ++ non ha una parola chiave per “la class base” ( super o base ) poiché C ++ supporta l’ereditarietà multipla che può portare ad ambiguità.

 class left { public: void foo(); }; class right { public: void foo(); }; class bottom : public left, public right { public: void foo() { //base::foo();// ambiguous left::foo(); right::foo(); // and when foo() is not called for 'this': bottom b; b.left::foo(); // calls b.foo() from 'left' b.right::foo(); // call b.foo() from 'right' } }; 

Per inciso, non è ansible derivare direttamente dalla stessa class due volte poiché non ci sarà modo di riferirsi a una delle classi base rispetto all’altra.

 class bottom : public left, public left { // Illegal }; 

Dato una class genitore chiamata Parent e una class figlio chiamata Child , puoi fare qualcosa di simile a questo:

 class Parent { public: void print(int x); } class Child : public Parent { void print(int x) override; } void Parent::print(int x) { // some default behavior } void Child::print(int x) { // use Parent's print method; implicitly passes 'this' to Parent::print Parent::print(x); } 

Nota che Parent è il nome effettivo della class e non una parola chiave.

Se la tua class base è chiamata Base e la tua funzione è chiamata FooBar() puoi chiamarla direttamente usando Base::FooBar()

 void Base::FooBar() { printf("in Base\n"); } void ChildOfBase::FooBar() { Base::FooBar(); } 

In MSVC c’è una parola chiave specifica per Microsoft per questo: __super


MSDN: consente di dichiarare esplicitamente che si sta chiamando un’implementazione di class base per una funzione che si sta ignorando.

 // deriv_super.cpp // compile with: /c struct B1 { void mf(int) {} }; struct B2 { void mf(short) {} void mf(char) {} }; struct D : B1, B2 { void mf(short) { __super::mf(1); // Calls B1::mf(int) __super::mf('s'); // Calls B2::mf(char) } }; 

Se il modificatore di accesso della funzione membro della class base è protetto O pubblico, puoi eseguire la funzione membro chiamata della class base dalla class derivata. È ansible effettuare una chiamata alla funzione della class base non virtuale e alla funzione membro virtuale dalla funzione membro derivato. Si prega di fare riferimento al programma.

 #include using namespace std; class Parent { protected: virtual void fun(int i) { cout< <"Parent::fun functionality write here"< 

Produzione:

 $ g++ base_function_call_from_derived.cpp $ ./a.out Child::fun partial functionality write here Parent::fun functionality write here Parent::fun3 functionality write here Child::fun1 partial functionality write here Parent::fun1 functionality write here 
 struct a{ int x; struct son{ a* _parent; void test(){ _parent->x=1; //success } }_son; }_a; int main(){ _a._son._parent=&_a; _a._son.test(); } 

Esempio di riferimento.