Puedo llamar a una clase base virtual de la función si estoy en lo primordial es?
-
21-08-2019 - |
Pregunta
Decir que tengo clases Foo
y Bar
establecer como este:
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 anotado en el código, me gustaría ser capaz de llamar a la clase base de la función que estoy primordial.En Java existe la super.funcname()
la sintaxis.Es esto posible en C++?
Solución
La sintaxis C ++ es así:
class Bar : public Foo {
// ...
void printStuff() {
Foo::printStuff(); // calls base class' function
}
};
Otros consejos
Sí,
class Bar : public Foo
{
...
void printStuff()
{
Foo::printStuff();
}
};
Es lo mismo que super
en Java, excepto que permite llamar a las implementaciones de diferentes bases cuando se tiene la 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 es necesario llamar a la implementación de la clase base, cuando no se encuentre 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 hace esto por una gran cantidad de funciones en su clase:
class Foo {
public:
virtual void f1() {
// ...
}
virtual void f2() {
// ...
}
//...
};
class Bar : public Foo {
private:
typedef Foo super;
public:
void f1() {
super::f1();
}
};
Esto puede ahorrar un poco de escritura si desea cambiar el nombre de Foo.
Si desea llamar a una función de la clase base de su clase derivada sólo tiene que llamar dentro de la función reemplazada con mencionar el nombre de la clase base (como Foo :: printStuff () ).
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();
}
Una vez más se puede determinar en tiempo de ejecución que funcionan para llamar usando el objeto de esa clase (derivado o base) .Pero esto requiere su función en la clase base debe ser marcado como virtual.
siguiente código
#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();
}
comprobar 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 forma de hacerlo es mediante el Base :: función como decir @sth
Si se le puede llamar. sintaxis de C ++ para llamar a la función de la clase padre en la clase de niño es
class child: public parent {
// ...
void methodName() {
parent::methodName(); // calls Parent class' function
}
};
Más información sobre la función primordial .