假设我有如下设置的类 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++中，调用派生类方法时必须显式命名基类。这可以从派生类的任何方法中完成。覆盖是与同名方法的特殊情况。在Java中不存在多重继承，因此您可以使用super来唯一命名基类。C++语法如下：
class Bar : public Foo {
// ...
void printStuff() override { // help the compiler to check
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;
}
x的类型设置为Base*并使用Base::Foo语法。 - TTimo如果你在类中有很多函数需要这样做：
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() ;
}
};
可以的。在子类中调用父类函数的C++语法是：
class child: public parent {
// ...
void methodName() {
parent::methodName(); // calls Parent class' function
}
};
了解更多关于函数覆盖的内容。
检查一下这个...
#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 所说的那样。