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

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

первое, что он говорит по этому поводу-не делай этого.

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

дано

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

это плохая идея, потому что аргументы по умолчанию, которые вы получаете, будут зависеть от статический тип объекта, тогда как 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);

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

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

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