假设我有课程Foo并Bar设置如下：
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;
}
};
如代码中所述，我希望能够调用我正在覆盖的基类函数。在Java中有super.funcname()语法。这在 C++ 中可能吗？
C++ 语法是这样的：
class Bar : public Foo {
// ...
void printStuff() {
Foo::printStuff(); // calls base class' function
}
};
是的，
class Bar : public Foo
{
...
void printStuff()
{
Foo::printStuff();
}
};
它与 Java 中的相同super，只是当您具有多重继承时，它允许从不同的基础调用实现。
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();
}
};
有时你需要调用基类的实现，当你不在派生函数中时......它仍然有效：
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;
}
以防万一您为班级中的许多功能执行此操作：
class Foo {
public:
virtual void f1() {
// ...
}
virtual void f2() {
// ...
}
//...
};
class Bar : public Foo {
private:
typedef Foo super;
public:
void f1() {
super::f1();
}
};
如果你想重命名 Foo. 这可能会节省一些写作。
如果你想从它的派生类调用基类的函数，你可以简单地在重写的函数内部调用并提到基类名称（如Foo::printStuff()）。
代码在这里
#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();
}
同样，您可以在运行时确定使用该类的对象（派生或基类）调用哪个函数。但这要求您在基类中的函数必须标记为虚拟。
下面的代码
#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();
}
如果有多个继承级别，您可以指定直接基类，即使实际实现处于较低级别。
class Foo
{
public:
virtual void DoStuff ()
{
}
};
class Bar : public Foo
{
};
class Baz : public Bar
{
public:
void DoStuff ()
{
Bar::DoStuff() ;
}
};
在此示例中，类Baz指定Bar::DoStuff()尽管类Bar不包含DoStuff的实现。这是一个细节，巴兹不需要知道。
显然，调用Bar::DoStuff比调用Foo::DoStuff更好，以防更高版本的Bar也覆盖此方法。
检查这个...
#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;
}
输出
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
最好的方法是使用base::function作为@sth
是的，您可以调用它。在子类中调用父类函数的 C++ 语法是
class child: public parent {
// ...
void methodName() {
parent::methodName(); // calls Parent class' function
}
};
阅读有关函数覆盖的更多信息。