Say I have classes Foo and Bar set up like this:
class Foo { public: int x; virtual void printStuff() { std::cout As annotated in the code, I'd like to be able to call the base class's function that I'm overriding. In Java there's the super.funcname() syntax. Is this possible in C++?
The C++ syntax is like this:
class Bar : public Foo { // ... void printStuff() { Foo::printStuff(); // calls base class' function } }; Yes,
class Bar : public Foo { ... void printStuff() { Foo::printStuff(); } }; It is the same as super in Java, except it allows calling implementations from different bases when you have multiple inheritance.
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(); } }; Sometimes you need to call the base class' implementation, when you aren't in the derived function...It still works:
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; } Just in case you do this for a lot of functions in your class:
class Foo { public: virtual void f1() { // ... } virtual void f2() { // ... } //... }; class Bar : public Foo { private: typedef Foo super; public: void f1() { super::f1(); } }; This might save a bit of writing if you want to rename Foo.
If you want to call a function of base class from its derived class you can simply call inside the overridden function with mentioning base class name(like Foo::printStuff()).
code goes here
#include using namespace std; class Foo { public: int x; virtual void printStuff() { coutprintStuff(); } Again you can determine at runtime which function to call using the object of that class(derived or base).But this requires your function at base class must be marked as virtual.
code below
#include using namespace std; class Foo { public: int x; virtual void printStuff() { coutprintStuff();/////this call the base function foo=new Bar; foo->printStuff(); } check this...
#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 gogo(7); obj->gogo1(7); obj->gogo2(7); obj->gogo3(7); std::cout gogo(7); base->gogo1(7); base->gogo2(7); base->gogo3(7); std::string s; std::cout > s; return 0; } output
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 the best way is using the base::function as say @sth
Yes you can call it. C++ syntax for calling parent class function in child class is
class child: public parent { // ... void methodName() { parent::methodName(); // calls Parent class' function } }; Read more about function overriding.