虚函数可以有默认参数吗？

Question

如果我声明一个基类（或接口类）并为其一个或多个参数指定默认值，则派生类是否必须指定相同的默认值，如果不是，哪些默认值将在派生类中体现？

附录：我也对如何跨不同编译器处理此问题以及在这种情况下“推荐”实践的任何输入感兴趣。

Answer 1

虚拟可能有默认值。基类中的默认值不会被派生类继承。

使用哪个默认值——即基类“还是派生类”——由用于调用函数的静态类型决定。如果通过基类对象、指针或引用进行调用，则使用基类中表示的默认值。相反，如果通过派生类对象、指针或引用进行调用，则使用派生类中表示的默认值。标准报价下方有一个示例说明了这一点。

某些编译器可能会执行不同的操作，但这就是 C++03 和 C++11 标准的规定：

8.3.6.10：

虚函数调用（10.3）使用
中的默认参数
虚函数的声明
决定
通过表示对象的指针或引用的静态类型。一个
派生函数中的重写函数
类不会从函数中获取默认参数
覆盖。示例：

<前><代码>结构A {
虚拟无效 f(int a = 7);
};
结构 B ：公共 A {
无效 f(int a);
};
无效 m()
{
B* pb = 新 B;
A* pa = pb;
pa->f(); //好的，调用 pa->B::f(7)
pb->f(); //错误：B::f() 的参数数量错误
}

---

这是一个示例程序，用于演示采用的默认值。为了简洁起见，我在这里使用 struct 而不是 class —— class 和 struct 正是除了默认可见性之外，几乎所有方面都相同。

#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>

using std::stringstream;
using std::string;
using std::cout;
using std::endl;

struct Base { virtual string Speak(int n = 42); };
struct Der : public Base { string Speak(int n = 84); };

string Base::Speak(int n) 
{ 
    stringstream ss;
    ss << "Base " << n;
    return ss.str();
}

string Der::Speak(int n)
{
    stringstream ss;
    ss << "Der " << n;
    return ss.str();
}

int main()
{
    Base b1;
    Der d1;

    Base *pb1 = &b1, *pb2 = &d1;
    Der *pd1 = &d1;
    cout << pb1->Speak() << "\n"    // Base 42
        << pb2->Speak() << "\n"     // Der 42
        << pd1->Speak() << "\n"     // Der 84
        << endl;
}

该程序的输出（在 MSVC10 和 GCC 4.4 上）是：

Base 42
Der 42
Der 84

Answer 2

这是 Herb Sutter 早期的一篇本周大师帖子的主题。

他就这个问题说的第一句话是“不要那样做”。

更详细地说，是的，您可以指定不同的默认参数。它们的工作方式与虚拟函数不同。虚函数是在对象的动态类型上调用的，而默认参数值是基于静态类型的。

鉴于

class A {
    virtual void foo(int i = 1) { cout << "A::foo" << i << endl; }
};
class B: public A {
    virtual void foo(int i = 2) { cout << "B::foo" << i << endl; }
};
void test() {
A a;
B b;
A* ap = &b;
a.foo();
b.foo();
ap->foo();
}

你应该得到
答::foo1
B::foo2
B::foo1

Answer 3

这是一个坏主意，因为您获得的默认参数将取决于对象的静态类型，而分派到的虚拟函数将取决于动态 类型。

也就是说，当您使用默认参数调用函数时，无论该函数是否为虚拟函数，默认参数都会在编译时被替换。

@cppcoder 在他的[已关闭]问题中提供了以下示例：

struct A {
    virtual void display(int i = 5) { std::cout << "Base::" << i << "\n"; }
};
struct B : public A {
    virtual void display(int i = 9) override { std::cout << "Derived::" << i << "\n"; }
};

int main()
{
    A * a = new B();
    a->display();

    A* aa = new A();
    aa->display();

    B* bb = new B();
    bb->display();
}

产生以下输出：

Derived::5
Base::5
Derived::9

借助上面的解释，很容易看出原因。在编译时，编译器会替换指针静态类型的成员函数中的默认参数，使 main 函数等效于以下内容：

    A * a = new B();
    a->display(5);

    A* aa = new A();
    aa->display(5);

    B* bb = new B();
    bb->display(9);

Answer 4

正如其他答案所详述的那样，这是个坏主意。然而，由于没有人提到简单有效的解决方案，这里是：将参数转换为结构体，然后您可以将默认值设置为结构体成员！

所以，不要这样做

//bad idea
virtual method1(int x = 0, int y = 0, int z = 0)

，

//good idea
struct Param1 {
  int x = 0, y = 0, z = 0;
};
virtual method1(const Param1& p)

Answer 5

正如您从其他答案中看到的，这是一个复杂的主题。而不是尝试这样做或理解它的作用（如果你现在必须问，维护者将不得不在一年后询问或查找它）。

相反，应在基类中使用默认参数创建一个公共非虚函数。然后，它调用一个私有或受保护的虚拟函数，该函数没有默认参数，并根据需要在子类中重写。那么你就不必担心它如何工作的细节，而且代码非常明显。

Answer 6

您可能可以通过测试很好地弄清楚这一点（即，它是该语言的足够主流的部分，大多数编译器几乎肯定都能正确执行，除非您看到编译器之间的差异，否则它们的输出可以被认为是相当权威的）。

#include <iostream>

struct base { 
    virtual void x(int a=0) { std::cout << a; }
    virtual ~base() {}
};

struct derived1 : base { 
    void x(int a) { std:: cout << a; }
};

struct derived2 : base { 
    void x(int a = 1) { std::cout << a; }
};

int main() { 
    base *b[3];
    b[0] = new base;
    b[1] = new derived1;
    b[2] = new derived2;

    for (int i=0; i<3; i++) {
        b[i]->x();
        delete b[i];
    }

    derived1 d;
    // d.x();       // won't compile.
    derived2 d2;
    d2.x();
    return 0;
}