Esta pergunta refere-se a problemas comuns discutidos nestas perguntas:

As funções virtuais podem ter parâmetros padrão?

Parâmetros padrão das funções virtuais

Aqui está o que atualmente acontece no c ++ com parâmetros padrão para funções virtuais:

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

resultado:

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

Este é o comportamento que eu gostaria que existisse nos parâmetros padrão da função virtual 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;
}

resultado:

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

Então, basicamente, se eu quiser substituir um parâmetro padrão em uma classe pai, apenas criarei um novo foo com esse número de argumentos. Observe que o derivado substitui a condição no-arg, mas não a condição one-arg. Como observação, meu projeto atual usa uma classe base puramente virtual. Costumo ter ponteiros do tipo de classe base e do tipo de classe derivada. Quero que uma chamada de qualquer um dos ponteiros tenha o mesmo resultado.

QUESTÕES:

Eu li muitas perguntas relacionadas a esse assunto, mas todas elas parecem não dar soluções razoáveis. A maioria das soluções resultaria em códigos mais feios em todo o projeto.

Alguns dizem "Não use parâmetros padrão em funções virtuais", mas então eu precisaria colocar o padrão em todos os lugares que chamo de função. Parece que seria melhor apenas colocar um comentário que diz: "também altere a classe base" e "também altere a classe derivada" do que precisar mudar em todos os lugares onde a função é chamada.

Alguns dizem ter apenas os parâmetros padrão na classe base, mas isso significa que qualquer ponteiro para um objeto derivado precisaria ser convertido de volta em um ponteiro base antes que os padrões pudessem ser usados. Isso torna muito código feio também.

Existem razões pelas quais devo evitar o design acima?