重写方法时 virtual 关键字意味着什么？

Question

重写方法时关键字virtual有什么作用？我没有使用它，一切正常。

每个编译器在这方面的行为都相同吗？

我应该使用它还是不应该使用它？

Answer 1

如果没有它，您就无法重写成员函数。

您只能隐藏一个。

struct Base {
   void foo() {}
};

struct Derived : Base {
   void foo() {}
};

Derived::foo不覆盖Base::foo；它只是隐藏它，因为它具有相同的名称，因此以下内容：

Derived d;
d.foo();

调用Derived::foo。

virtual 启用多态性，以便您实际上重写函数：

struct Base {
   virtual void foo() {}
};

struct Derived : Base {
   virtual void foo() {} // * second `virtual` is optional, but clearest
};

Derived d;
Base& b = d;
b.foo();

这会调用 Derived::foo，因为现在 >overrides Base::foo — 你的对象是多态的。

（由于切片问题<，您还必须为此使用引用或指针/a>.)

---

• Derived::foo 不需要重复 virtual 关键字，因为 Base::foo 已经使用了它。这是由标准保证的，您可以信赖。然而，一些人认为为了清楚起见最好保留这一点。

Answer 2

基类中的虚拟方法将在层次结构中级联，使具有相同签名的每个子类方法也成为虚拟方法。

class Base{
public:
  virtual void foo(){}
};

class Derived1 : public Base{
public:
  virtual void foo(){} // fine, but 'virtual' is no needed
};

class Derived2 : public Base{
public:
  void foo(){} // also fine, implicitly 'virtual'
};

如果仅用于文档目的，我建议编写virtual。

Answer 3

当一个函数是虚拟的时，它在整个层次结构中仍然是虚拟的，无论您是否每次都明确指定它是虚拟的。重写方法时，使用 virtual 以便更明确 - 没有其他区别:)

class A
{
    virtual void f() 
    {
      /*...*/
    };
};

class B:public A;
{
    virtual void f()  //same as just void f()
    {
        /*...*/
    };
};

Answer 4

扩展 Light Races 的答案，也许这会帮助一些人了解它在做什么。

struct Base {
public:
    void foo() {
        printf_s("Base::foo\n");
    }
};

struct Derived : Base {
    void foo() {
        printf_s("Derived::foo\n");
    }
};

struct BaseVirtual {
public:
    virtual void foo() {
        printf_s("BaseVirtual::foo\n");
    }
};

struct DerivedVirtual : BaseVirtual {
    virtual void foo() {
        printf_s("DerivedVirtual::foo\n");
    } 
};

Derived d;
d.foo(); // Outputs: Derived::foo

Base& b = d;
b.foo(); // Outputs: Base::foo

DerivedVirtual d2;
d2.foo(); // Outputs: DerivedVirtual::foo

BaseVirtual& b2 = d2;
b2.foo(); // Outputs: DerivedVirtual::foo