2

问题来自 C++ 常见问题解答。

http://www.parashift.com/c++-faq-lite/protected-virtuals.html

使用公共重载虚拟的代码：

class Base {
public:
  virtual void f(int x);    ← may or may not be pure virtual
  virtual void f(double x); ← may or may not be pure virtual
};

通过 Public Overloaded Non-Virtuals Call Protected Non-Overloaded Virtuals 成语改进这一点：

class Base {
public:
  void f(int x)    { f_int(x); }  ← non-virtual
  void f(double x) { f_dbl(x); }  ← non-virtual
protected:
  virtual void f_int(int);
  virtual void f_dbl(double);
};

作者说：

Public Overloaded Non-Virtuals Call Protected Non-Overloaded Virtuals 习语的想法是将公共重载方法更改为非虚拟，并使那些调用受保护的非重载虚拟。

但我不明白作者对这个成语如何提高风险所说的话：

该成语将正确管理隐藏规则的复杂性打包到基类（单数）中。这意味着派生类（复数）或多或少会自动处理隐藏规则，因此生成这些派生类的各种开发人员几乎可以完全专注于派生类本身的细节——他们不需要关心 (微妙且经常被误解）隐藏规则。这大大降低了派生类的编写者搞砸隐藏规则的机会。

为什么这解决了隐藏问题？据我了解，名称隐藏与成员函数是否“虚拟”无关。如果“base”的派生类重写了函数 f()，它仍然会隐藏 f(int) 和 f(double)，对吗？

从这个习语中我只能看到作者将'base'虚拟f（）更改为非虚拟，并将辅助函数f_int（），f_dbl（）放在'protected virtual'中，就像成语的名字所说的那样。它还没有什么好处，但相反消除了从基类指针/引用动态绑定的可能性。这个成语的真正好处是什么？

更新

克雷克，你是在说这个吗？我不完全理解你回答的第二段。你能举个例子吗？

class base {
public: 
    virtual void f(int x);
    virtual void f(double x);
}

class derived : public base {
public:
    virtual int f(int x); // oops, will hide base::f(int x) AND base::f(double x)
}

base *bp = new base();
base *dp = new derived();
bp->f(int i);    // ok
dp->f(int i);    // surprise!
dp->f(double d); // compile error!


class Base {
public:
    void f(int x)    { f_int(x); }  
    void f(double x) { f_dbl(x); } 
protected:
    virtual void f_int(int);
    virtual void f_dbl(double);
};

class derived : public base {
public:
    // nothing to override here 'cause f() is non virtual
protected:
    // because f_int() and f_dbl are unique names, override or hide f_int() will not affect f_dbl()?
    virtual int f_int(int);  // oops, will hide base::f(int x), but developer may want this on purpose
                             // no effect on f_dbl(), which is good
}

base bobj;
derived dobj;
bobj.f(int i);    // ok
dobj.f(double d); // ok
4

3 回答 3

2

如果派生类声明了void f(int)，那么它会覆盖虚函数，并且说明virtual符是隐含的。如果派生类声明int f(int)，它会隐藏基函数。我猜你对此很熟悉。

当您希望其他人基于您的基类开发代码时，问题就来了。使用幼稚的方法，每个派生类都必须小心添加正确的覆盖，以免意外隐藏函数并获得正常工作但错误的程序（即用户说f()但得到错误的东西）。使用“public non-virtual”习惯用法，用户总是可以f()放心调用，并且库开发人员可以通过覆盖唯一命名的受保护函数来仅覆盖她感兴趣的部分，而无需触及可能影响其他用户的名称.

于 2012-08-06T08:53:47.487 回答
0

我所能看到的是，它会减少您链接到SomeDerived::f()而不是使用 virtual的可能性Base::f()，尽管我不记得到目前为止我已经发现编译器对此有罪。正在寻找其他人提出更好的答案...

于 2012-08-06T08:53:02.263 回答
0

至少从历史上看，使用非公共虚函数的主要动机是支持合约编程。Base定义合同 中的（非虚拟）公共功能，具有assert（或类似的）前置条件和后置条件以及不变量。他们转发到私有或受保护的虚拟功能以进行实际工作。因此，例如，clone可以定义经典函数：

class Base
{
    virtual Base* doClone() const = 0;
public:
    Base* clone() const
    {
        Base* results = doClone();
        assert( typeid(*this) == typeid( *results ) );
        return results;
    }
};

在 的情况下clone，这种保护可能是矫枉过正的；我还没有看到由于派生类错误实现它（或未能实现它，如果有多个派生级别）导致的任何问题。然而，对于大多数其他功能，它是开发健壮软件的一种强大而有效的方法。

如果您在接口中有重载函数，并且它们有不同的实现，我看不出有任何不重载虚函数的真正理由。

于 2012-08-06T09:20:15.227 回答