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

virtual cpp

Question

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 anota en el código, me gustaría poder llamar a la función de la clase base que estoy anulando. En Java hay la sintaxis de super.funcname() . ¿Es esto posible en C ++?

Answer 1

A veces es necesario llamar a la implementación de la clase base, cuando no está 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;
}

Answer 2

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.

Answer 3

La sintaxis de C ++ es así:

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

Answer 4

Mira esto...

#include <stdio.h>
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 manera es usar la función base :: como dice @sth

Answer 5

Sí,

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

Es lo mismo que super en Java, excepto que permite invocar implementaciones 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();
}
};

Answer 6

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

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

Lea más sobre la overriding funciones.

Answer 7

Si desea llamar a una función de la clase base desde su clase derivada, simplemente puede llamar dentro de la función anulada con la mención del nombre de la clase base (como Foo :: printStuff () ).

el código va aquí

#include <iostream>
using namespace std;
class Foo
{
public:
int x;
virtual void printStuff()
{
cout<<"Base Foo printStuff called"<<endl;
}
};
class Bar : public Foo
{
public:
int y;
void printStuff()
{
cout<<"derived Bar printStuff called"<<endl;
Foo::printStuff();/////also called the base class method
}
};
int main()
{
Bar *b=new Bar;
b->printStuff();
}

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

código abajo

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