Czy funkcje wirtualne mogą mieć domyślne parametry?

To był temat jednego z pierwszych postów Herba Suttera "Guru tygodnia".

Bardziej szczegółowo, tak, można określić różne domyślne parametry. Nie będą działać tak samo jak funkcje wirtualne. Funkcja wirtualna jest wywoływana na typie dynamicznym obiektu, podczas gdy domyślne wartości parametrów są oparte na typie statycznym.

Given

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

Powinieneś Odp:: foo1 B:: foo2 B:: foo1

Jak widać z innych odpowiedzi jest to skomplikowany temat. Zamiast próbować to zrobić lub zrozumieć, co to robi (jeśli musisz zapytać teraz, opiekun będzie musiał zapytać lub sprawdzić to za rok).

Zamiast tego utwórz publiczną nie wirtualną funkcję w klasie bazowej z domyślnymi parametrami. Następnie wywołuje prywatną lub chronioną funkcję wirtualną, która nie ma domyślnych parametrów i jest zastępowana w klasach potomnych w razie potrzeby. Wtedy nie musisz się martwić o szczegóły jak to będzie działać i Kod jest bardzo oczywiste.

Jest to jeden, który prawdopodobnie można dowiedzieć się dość dobrze przez testowanie (tj., jest to wystarczająco główny element języka, że większość kompilatorów prawie na pewno dobrze i jeśli nie widzisz różnic między kompilatorami, ich wyjście może być uznane za dość dobrze autorytatywne).

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

Jest to zły pomysł, ponieważ domyślne argumenty będą zależeć od typu static obiektu, podczas gdy funkcja virtual będzie zależeć od typu dynamic .

To znaczy, gdy wywołujesz funkcję z domyślnymi argumentami, domyślne argumenty są zastępowane podczas kompilacji, niezależnie od tego, czy funkcja jest virtual, czy nie.

@cppcoder zaproponował następujący przykład w swoim [closed] pytanie :

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

, która daje następujące wyjście:

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

Z pomocą powyższego wyjaśnienia łatwo zrozumieć, dlaczego. W czasie kompilacji kompilator zastępuje domyślne argumenty z funkcji składowych statycznych typów wskaźników, czyniąc jego main funkcją równoważną następującej:

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

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

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

Jak Inne odpowiedzi mają szczegółowe, to zły pomysł. Ponieważ jednak nikt nie wspomina o prostym i skutecznym rozwiązaniu, oto jest: przekonwertuj swoje parametry na struct i wtedy możesz mieć domyślne wartości na struct members!

Więc zamiast

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

Zrób to,

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