如果我重写基类的虚函数，我可以调用它吗?

小开

是的,

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();
}
};

小开

最佳答案

在c++中，在调用派生类方法时必须显式地命名基类。这可以从派生类的任何方法中完成。重写是同名方法的特殊情况。在Java中没有多重继承，所以你可以使用super来唯一地命名基类。c++语法是这样的:

class Bar : public Foo {
// ...


void printStuff() override {  // help the compiler to check
Foo::printStuff(); // calls base class' function
}
};

小开

以防你对类中的很多函数都这样做:

class Foo {
public:
virtual void f1() {
// ...
}
virtual void f2() {
// ...
}
//...
};


class Bar : public Foo {
private:
typedef Foo super;
public:
void f1() {
super::f1();
}
};

如果您想重命名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;
}

小开

如果你想从基类的派生类中调用基类的函数，你可以简单地在被覆盖的函数内部调用，并提到基类名(如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();
}

小开

检查下这个吗……

#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

最好的方法是使用基地:函数作为@sth

小开

是的，你可以这么叫。在子类中调用父类函数的c++语法是

class child: public parent {
// ...


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

阅读关于函数压倒一切的的更多信息。

小开

如果有多个继承级别，则可以指定直接基类，即使实际实现处于较低级别。

class Foo
{
public:
virtual void DoStuff ()
{
}
};


class Bar : public Foo
{
};


class Baz : public Bar
{
public:
void DoStuff ()
{
Bar::DoStuff() ;
}
};

在这个例子中，类巴兹指定了酒吧:DoStuff ()，尽管类酒吧不包含DoStuff的实现。这是一个细节，巴兹不需要知道。

显然，调用酒吧:DoStuff比调用Foo: DoStuff更好，以防酒吧的后续版本也重写此方法。