为什么在 C++ 中隐式传播方法的“虚拟性”？答案

【问题标题】：Why is the "virtuality" of methods implicitly propagated in C++?为什么在 C++ 中隐式传播方法的“虚拟性”？
【发布时间】：2012-12-07 23:46:04
【问题描述】：

移除阻止方法虚拟性传播的能力的原因是什么？

让我更清楚一点：在 C++ 中，无论你在派生类中编写“virtual void foo()”还是“void foo()”，只要在基类中声明 foo，它就会是虚拟的。

这意味着通过派生* 指针调用 foo() 将导致虚拟表查找（如果派生2 函数覆盖 foo），即使程序员不希望这种行为。

让我举一个例子（对我来说看起来很明显），说明阻止虚拟传播有什么用处：

template <class T>
class Iterator // Here is an iterator interface useful for defining iterators
{              // when implementation details need to be hidden
public:
    virtual T& next() { ... }
    ...
};

template <class T>
class Vector
{
public:
    class VectIterator : public Iterator<T>
    {
    public:
        T& next() { ... }
        ...
    };
    ...
};

在上面的示例中，可以使用 Iterator 基类以更清晰和面向对象的方式实现“类型擦除”的一种形式。（有关类型擦除的示例，请参阅 http://www.artima.com/cppsource/type_erasure.html。）

但是，在我的示例中，可以直接使用 Vector::VectIterator 对象（在大多数情况下都会这样做），以便在不使用接口的情况下访问真实对象。

如果没有传播虚拟性，即使从指针或引用调用 Vector::VectIterator::next() 也不会是虚拟的，并且能够内联并高效运行，就像 Iterator 接口没有一样'不存在。

【问题讨论】：

只要编译器能够从上下文中推断出类型，即使函数是虚函数，它也能内联事物。特别是对于以多态方式使用它们的迭代器是危险的，因为大多数算法都按值获取它们。
C++ 注释参考手册解释了为什么 C++ 会以它的方式做很多事情。
@brianbeuning 对于很多事情（尤其是模板设计），更喜欢 D&E（C++ 的设计和演变）

标签： c++ templates polymorphism virtual type-erasure

【解决方案1】：

C++11 为此添加了上下文关键字final。

class VectIterator : public Iterator<T>
{
public:
    T& next() final { ... }
    ...
};

struct Nope : VecIterator {
    T& next() { ... } // ill-formed
};

【讨论】：

【解决方案2】：

简单的答案是：不要混合具体和抽象接口！在您的示例中，显而易见的方法是使用非virtual 函数next() 委托给virtual 函数，例如do_next()。派生类将覆盖do_next()，可能委托给非virtual 函数next()。由于next() 函数很可能是inline，因此委托不涉及任何成本。

【讨论】：

不错的技巧，看起来已经足够好了。正如 R. Martinho Fernandes 所说，在 C++11 中，final 关键字会做到这一点。
这种模式是protected 有用的很好的例子之一；通常do_next() 可以被保护。

【解决方案3】：

在我看来，这种传播的一个很好的原因是virtual 析构函数。在 C++ 中，当你有一个带有一些 virtual 方法的基类时，你应该定义析构函数 virtual。这是因为某些代码可能有一个基类指针，该指针实际上指向派生类，然后尝试删除该指针（有关更多详细信息，请参见question）。通过将基类中的析构函数定义为vritual，您可以确保所有指向派生类的基类指针（在任何继承级别）都将正确删除。

【讨论】：

【解决方案4】：

我认为原因是在继承结构的中途移除虚拟性会非常令人困惑（我在下面有一个复杂性示例）。

但是，如果您关心的是删除一些虚拟呼叫的微优化，那么我不会担心。只要您内联虚拟子方法的代码，并且您的迭代器是按值传递而不是引用，一个好的优化编译器已经能够在编译时看到动态类型并内联整个尽管它是一种虚拟方法，但对你来说还是有用的！

但为了完整起见，请使用可以去虚拟化的语言考虑以下内容：

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

class B : public A
{
public:
    void Foo() { } // De-virtualize
};

class C: public B
{
public:
    void Foo() { } // not virtual
};

void F1(B* obj)
{
    obj->Foo();
    static_cast<A*>(obj)->Foo();
}

C test_obj;
F1(test_obj);   // Which two methods are called here?

您可以针对将调用哪些方法制定规则，但明显的选择会因人而异。仅传播方法的虚拟性要简单得多。

【讨论】：