Виртуальные функции могут иметь параметры по умолчанию?

Это была тема одной из ранних работ Херба Саттера гуру недели сообщения.

более подробно, да, вы можете указать различные параметры по умолчанию. Они не будут работать так же, как виртуальные функции. Виртуальная функция вызывается для динамического типа объекта, а значения параметров по умолчанию основаны на статическом типе.

дано

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

вы должны получить A:: foo1 B:: foo2 B:: foo1

Как вы можете видеть из других ответов, это сложная тема. Вместо того, чтобы пытаться сделать это или понять, что он делает (если вам нужно спросить сейчас, сопровождающий должен будет спросить или посмотреть его через год).

вместо этого создайте общедоступную не виртуальную функцию в базовом классе с параметрами по умолчанию. Затем он вызывает закрытую или защищенную виртуальную функцию, которая не имеет параметров по умолчанию и при необходимости переопределяется в дочерних классах. Тогда тебе не о чем беспокоиться. особенности того, как это будет работать, и код очень очевидны.

Это тот, который вы, вероятно, можете понять достаточно хорошо путем тестирования (т. е. это достаточно распространенная часть языка, что большинство компиляторов почти наверняка получают его правильно, и если вы не видите различий между компиляторами, их вывод можно считать довольно авторитетным).

#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;
}

это плохая идея, потому что аргументы по умолчанию, которые вы получите, будут зависеть от static тип объекта, тогда как virtual функция отправляется будет зависеть от динамический тип.

то есть, когда вы вызываете функцию с аргументами по умолчанию, аргументы по умолчанию подставляются во время компиляции, независимо от того, является ли функция virtual или нет.

@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);

Как и другие ответы, его плохая идея. Однако, поскольку никто не упоминает простое и эффективное решение, Вот оно: преобразуйте свои параметры в struct, а затем вы можете иметь значения по умолчанию для членов struct!

Так что вместо

//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)