Como chamar uma function de class pai da function de class derivada?

Como faço para chamar a function pai de uma class derivada usando C ++? Por exemplo, eu tenho uma class chamada parent e uma class chamada child que é derivada do pai. Dentro de cada class há uma function de print . Na definição da function de impressão da criança, gostaria de fazer uma chamada para a function de impressão dos pais. Como eu iria fazer isso?

Eu assumirei o risco de declarar o óbvio: você chama a function, se ela estiver definida na class base, estará automaticamente disponível na class derivada (a menos que seja private ).

Se houver uma function com a mesma assinatura na class derivada, você poderá desambiguá-la incluindo o nome da class base seguido de dois dois-pontos base_class::foo(...) . Você deve observar que, diferentemente do Java e do C #, o C ++ não possui uma palavra-chave para “a class base” ( super ou base ), pois o C ++ suporta inheritance múltipla, o que pode levar à ambigüidade.

 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' } }; 

Aliás, você não pode derivar diretamente da mesma class duas vezes, pois não haverá como se referir a uma das classs base sobre a outra.

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

Dada a class pai chamada Parent e child class chamada Child , você pode fazer algo assim:

 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); } 

Observe que o Parent é o nome real da class e não uma palavra-chave.

Se sua class base é chamada Base , e sua function é chamada FooBar() você pode chamá-la diretamente usando Base::FooBar()

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

No MSVC existe uma palavra-chave específica da Microsoft para isso: __super


MSDN: permite declarar explicitamente que você está chamando uma implementação de class base para uma function que está sobrescrevendo.

 // 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 o modificador de access da function de membro da class base estiver protegido OU public, você poderá chamar a function de membro da class base da class derivada. Chamada para a class base não-virtual e function de membro virtual da function de membro derivado pode ser feita. Por favor, consulte o programa.

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

Saída:

 $ 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(); } 

Exemplo de referência.