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

Jeśli zadeklaruję klasę bazową (lub klasę interfejsu) i określę wartość domyślną dla co najmniej jednego z jej parametrów, czy klasy pochodne muszą określać te same wartości domyślne, a jeśli nie, to które wartości domyślne będą widoczne w klasach pochodnych?

Dodatek: Interesuje mnie również, jak można to załatwić w różnych kompilatorach, oraz wszelkie dane wejściowe dotyczące „zalecanych” praktyk w tym scenariuszu.

Wirtualne mogą mieć wartości domyślne. Wartości domyślne w klasie bazowej nie są dziedziczone przez klasy pochodne.

To, która wartość domyślna jest używana - tj. Klasa bazowa „czy klasa pochodna” - jest określane przez typ statyczny użyty do wywołania funkcji. Jeśli wywołujesz za pośrednictwem obiektu klasy bazowej, wskaźnika lub odwołania, używana jest wartość domyślna oznaczona w klasie bazowej. I odwrotnie, jeśli wywołujesz za pośrednictwem obiektu klasy pochodnej, używany jest wskaźnik lub odwołanie, wartości domyślne oznaczone w klasie pochodnej. Pokazuje to przykład poniżej standardowego cytatu.

Niektóre kompilatory mogą zrobić coś innego, ale tak mówią standardy C ++ 03 i C ++ 11:

8.3.6.10:

Wywołanie funkcji wirtualnej (10.3) wykorzystuje domyślne argumenty w deklaracji funkcji wirtualnej określone przez statyczny typ wskaźnika lub referencji oznaczającej obiekt. Funkcja przesłaniająca w klasie pochodnej nie pobiera argumentów domyślnych z funkcji, którą przesłania. Przykład:

struct A {
  virtual void f(int a = 7);
};
struct B : public A {
  void f(int a);
};
void m()
{
  B* pb = new B;
  A* pa = pb;
  pa->f(); //OK, calls pa->B::f(7)
  pb->f(); //error: wrong number of arguments for B::f()
}

Oto przykładowy program pokazujący, jakie ustawienia domyślne są pobierane. Używam structtutaj znaków s zamiast classes po prostu dla zwięzłości - classi structsą one dokładnie takie same pod każdym względem, z wyjątkiem domyślnej widoczności.

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

Dane wyjściowe tego programu (na MSVC10 i GCC 4.4) to:

Base 42
Der 42
Der 84

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

Pierwszą rzeczą, jaką mówi na ten temat, jest: NIE ROBIĆ TEGO.

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

Dany

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ś otrzymać A :: foo1 B :: foo2 B :: foo1

To zły pomysł, ponieważ domyślne argumenty, które otrzymasz, będą zależały od statycznego typu obiektu, podczas gdy virtualfunkcja wysyłana do będzie zależała od typu dynamicznego .

Oznacza to, że kiedy wywołujesz funkcję z domyślnymi argumentami, domyślne argumenty są zastępowane w czasie kompilacji, niezależnie od tego, czy funkcja jest, virtualczy nie.

@cppcoder podał następujący przykład w swoim [zamkniętym] pytaniu :

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óry daje następujący wynik:

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

Na podstawie powyższego wyjaśnienia łatwo zrozumieć, dlaczego. W czasie kompilacji kompilator zastępuje domyślne argumenty z funkcji składowych typów statycznych wskaźników, dzięki czemu mainfunkcja jest równoważna z poniższym:

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

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

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

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

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

Jest to taki, który prawdopodobnie możesz dość dobrze zrozumieć, testując (tj. Jest to wystarczająco mainstreamowa część języka, że ​​większość kompilatorów prawie na pewno dobrze to rozumie i jeśli nie widzisz różnic między kompilatorami, ich wynik można uznać za całkiem autorytatywny).

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

Jak podają inne odpowiedzi, jest to zły pomysł. Ponieważ jednak nikt nie wspomina o prostym i skutecznym rozwiązaniu, oto jest: Konwertuj parametry na strukturę, a wtedy możesz mieć wartości domyślne na składowe struktury!

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)