Esta pregunta se refiere a problemas comunes discutidos en estas preguntas:

¿Pueden las funciones virtuales tener parámetros predeterminados?

Parámetros predeterminados de funciones virtuales

Esto es lo que sucede actualmente en c ++ con parámetros predeterminados para funciones virtuales:

struct Base
{
    virtual void foo(int one = 1, int two = 2)
            { cout << "one: " << one << " two: " << two << endl; }
};

struct Derived : public Base
{
    virtual void foo(int one = 3, int two = 4) 
        { Base::foo(one, two); cout << " derived!" << endl; }
};

int main()
{
    Base* b = new Base();
    Base* d = new Derived();

    Derived* dp = new Derived();

   b->foo();
   d->foo();
   dp->foo();

   return 0;
}

salida:

one: 1 two: 2
one: 1 two: 2
 derived!
one: 3 two: 4
 derived!

Este es el comportamiento que desearía que existiera en los parámetros predeterminados de la función virtual de c ++:

#include <iostream>

using namespace std;

struct Base
{
    virtual void foo () { foo(1, 2); }
    virtual void foo (int one) { foo(one, 2); }
    virtual void foo(int one, int two)
            { cout << "one: " << one << " two: " << two << endl; }
};

struct Derived : public Base
{   
    virtual void foo() { foo(3, 4); }
    virtual void foo(int one, int two) 
        { Base::foo(one, two); cout << " derived!" << endl; }
};

int main()
{
    Base* b = new Base();
    Base* d = new Derived();

    Derived* dp = new Derived();

   b->foo();
   d->foo();
   dp->foo();

   return 0;
}

salida:

one: 1 two: 2
one: 3 two: 4
 derived!
one: 3 two: 4
 derived!

Entonces, básicamente, si quiero anular un parámetro predeterminado en una clase principal, simplemente crearé un nuevo foo con esa cantidad de argumentos. Tenga en cuenta que el derivado anula la condición sin argumentos, pero no la condición de un argumento. Como nota al margen, mi proyecto actual utiliza una clase base puramente virtual. A menudo tengo punteros del tipo de clase base y del tipo de clase derivada. Quiero que una llamada de cualquier puntero tenga el mismo resultado.

PREGUNTAS

He leído muchas preguntas relacionadas con este tema, pero no todas parecen dar soluciones razonables. La mayoría de las soluciones darían como resultado un código más feo en todo el proyecto.

Algunos dicen "No use los parámetros predeterminados en las funciones virtuales", pero luego necesitaría poner el valor predeterminado en cada lugar que llame a la función. Parece que sería mejor simplemente poner un comentario que diga "también cambiar la clase base" y "también cambiar la clase derivada" que tener que cambiar en todas partes donde se llama la función.

Algunos dicen que solo tienen los parámetros predeterminados en la clase base, pero eso significa que cualquier puntero a un objeto derivado necesitaría ser devuelto a un puntero base antes de que se puedan usar los valores predeterminados. Eso también hace que muchos códigos sean feos.

¿Hay razones por las que debería evitar el diseño anterior?