Les fonctions virtuelles peuvent-elles avoir des paramètres par défaut?

C'était le sujet de L'un des premiers messages de Herb Sutter gourou de la semaine.

La première chose qu'il dit sur le sujet est de ne pas faire ça.

Plus En détail, oui, vous pouvez spécifier différents paramètres par défaut. Ils ne fonctionneront pas de la même manière que les fonctions virtuelles. Une fonction virtuelle est appelée Sur le type dynamique de l'objet, tandis que les valeurs des paramètres par défaut sont basées sur le type statique.

Donné

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

Vous devriez obtenir A::toto1 B:: foo2 B::toto1

Comme vous pouvez le voir dans les autres réponses, c'est un sujet compliqué. Au lieu d'essayer de le faire ou de comprendre ce qu'il fait (si vous devez demander maintenant, le mainteneur devra le demander ou le rechercher dans un an).

À la place, créez une fonction publique non virtuelle dans la classe de base avec les paramètres par défaut. Ensuite, il appelle une fonction virtuelle privée ou protégée qui n'a pas de paramètres par défaut et est remplacée dans les classes enfants si nécessaire. Alors vous n'avez pas à vous soucier de la détails de la façon dont cela fonctionnerait et le code est très évident.

C'est celui que vous pouvez probablement comprendre raisonnablement bien en testant (c'est-à-dire que c'est une partie suffisamment courante du langage que la plupart des compilateurs obtiennent presque certainement et à moins que vous ne voyiez des différences entre les compilateurs, leur sortie peut être considérée comme assez bien autoritaire).

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

C'est une mauvaise idée, car les arguments par défaut que vous obtenez dépendront du type static de l'objet, alors que la fonction virtual envoyée dépendra du type dynamic.

C'est-à-dire que lorsque vous appelez une fonction avec des arguments par défaut, les arguments par défaut sont substitués au moment de la compilation, que la fonction soit virtual ou non.

@cppcoder a offert l'exemple suivant dans son [fermé] question:

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

, Qui produit la sortie suivante:

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

, Avec l'aide de l'explication ci-dessus, il est facile de voir pourquoi. Au moment de la compilation, le compilateur remplace les arguments par défaut des fonctions membres des types statiques des pointeurs, rendant sa fonction main équivalente à la suivante:

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

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

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

Comme d'autres réponses l'ont détaillé, c'est une mauvaise idée. Cependant, puisque personne ne mentionne une solution simple et efficace, Le voici: Convertissez vos paramètres en struct et vous pouvez avoir des valeurs par défaut en struct members!

Donc au lieu de,

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

Faites ceci,

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