¿Puedo llamar a la función virtual de una clase base si la estoy anulando?

Digamos que tengo clases de Foo y Bar configuradas así:

 class Foo { public: int x; virtual void printStuff() { std::cout << x << std::endl; } }; class Bar : public Foo { public: int y; void printStuff() { // I would like to call Foo.printStuff() here... std::cout << y << std::endl; } }; 

Como se anotó en el código, me gustaría poder llamar a la función de la clase base que estoy anulando. En Java existe la syntax super.funcname() . ¿Es esto posible en C ++?

La syntax de C ++ es así:

 class Bar : public Foo { // ... void printStuff() { Foo::printStuff(); // calls base class' function } }; 

Sí,

 class Bar : public Foo { ... void printStuff() { Foo::printStuff(); } }; 

Es lo mismo que super en Java, excepto que permite implementar llamadas desde diferentes bases cuando tiene herencia múltiple.

 class Foo { public: virtual void foo() { ... } }; class Baz { public: virtual void foo() { ... } }; class Bar : public Foo, public Baz { public: virtual void foo() { // Choose one, or even call both if you need to. Foo::foo(); Baz::foo(); } }; 

A veces necesitas llamar a la implementación de la clase base, cuando no estás en la función derivada … Todavía funciona:

 struct Base { virtual int Foo() { return -1; } }; struct Derived : public Base { virtual int Foo() { return -2; } }; int main(int argc, char* argv[]) { Base *x = new Derived; ASSERT(-2 == x->Foo()); //syntax is trippy but it works ASSERT(-1 == x->Base::Foo()); return 0; } 

En caso de que hagas esto para muchas funciones en tu clase:

 class Foo { public: virtual void f1() { // ... } virtual void f2() { // ... } //... }; class Bar : public Foo { private: typedef Foo super; public: void f1() { super::f1(); } }; 

Esto podría ahorrar un poco de escritura si desea cambiar el nombre de Foo.

Si desea llamar a una función de la clase base desde su clase derivada, puede simplemente llamar dentro de la función invalidada mencionando el nombre de la clase base (como Foo :: printStuff () ).

el código va aquí

 #include  using namespace std; class Foo { public: int x; virtual void printStuff() { cout<<"Base Foo printStuff called"<printStuff(); } 

De nuevo, puede determinar en el tiempo de ejecución a qué función llamar utilizando el objeto de esa clase (derivada o base). Pero esto requiere que su función en la clase base se marque como virtual.

código debajo

 #include  using namespace std; class Foo { public: int x; virtual void printStuff() { cout<<"Base Foo printStuff called"<printStuff();/////this call the base function foo=new Bar; foo->printStuff(); } 

Mira esto…

 #include  class Base { public: virtual void gogo(int a) { printf(" Base :: gogo (int) \n"); }; virtual void gogo1(int a) { printf(" Base :: gogo1 (int) \n"); }; void gogo2(int a) { printf(" Base :: gogo2 (int) \n"); }; void gogo3(int a) { printf(" Base :: gogo3 (int) \n"); }; }; class Derived : protected Base { public: virtual void gogo(int a) { printf(" Derived :: gogo (int) \n"); }; void gogo1(int a) { printf(" Derived :: gogo1 (int) \n"); }; virtual void gogo2(int a) { printf(" Derived :: gogo2 (int) \n"); }; void gogo3(int a) { printf(" Derived :: gogo3 (int) \n"); }; }; int main() { std::cout << "Derived" << std::endl; auto obj = new Derived ; obj->gogo(7); obj->gogo1(7); obj->gogo2(7); obj->gogo3(7); std::cout << "Base" << std::endl; auto base = (Base*)obj; base->gogo(7); base->gogo1(7); base->gogo2(7); base->gogo3(7); std::string s; std::cout << "press any key to exit" << std::endl; std::cin >> s; return 0; } 

salida

 Derived Derived :: gogo (int) Derived :: gogo1 (int) Derived :: gogo2 (int) Derived :: gogo3 (int) Base Derived :: gogo (int) Derived :: gogo1 (int) Base :: gogo2 (int) Base :: gogo3 (int) press any key to exit 

la mejor forma es usar la función base :: como por ejemplo @sth

Sí, puedes llamarlo. La syntax de C ++ para llamar a la función de clase principal en la clase hija es

 class child: public parent { // ... void methodName() { parent::methodName(); // calls Parent class' function } }; 

Obtenga más información sobre la anulación de funciones.