Metoda z niezdefiniowanymi parametrami klasy abstrakcyjnej

Hej,
zastanawiam się czy istnieje możliwość zdefiniowania interfejsu,który zawierałby nazwę metody, lecz bez określenia parametrów.
Coś jak to:

class Abstract
{
public:
    virtual void create(...) = 0;
];

class A : public Abstract
{
public:
    void create(int a) override {}
};

class B : public Abstract
{
public:
    void create(int a, int b) override {}
    void create(bool b, double c) override {}
};

Kompilator Ci na to nie pozwoli, a gdyby nawet, to przecież wtedy operowanie funkcjami wirtualnymi (polimorfizm) nie będzie miało sensu.

Starą radą dla C++ jest trzymanie interfejsów niewirtualnych, a wirtualnych funkcji jako prywatnych (tutaj gadka Herba Suttera). W twoim przypadku będzie to tak wyglądać:

class Abstract {
private:
    virtual void create_() = 0;
];

class A : public Abstract {
public:
    void create(int a) { /* calls create_() */ }
private:
    virtual void create_() override {};
};

class B : public Abstract {
public:
    void create(int a, int b) override {  /* calls create_() */ }
    void create(bool b, double c) override {  /* calls create_() */ }
private:
    virtual void create_() override {};
};

Teoretycznie możesz się bawić np w listę parametrów jako std::vector<std::any>, ale pozwól że zapytam: po co? Co chcesz osiągnąć? Jeśli to nie jest czysto akademicka dywagacja, to brzmi jak problem XY

Można tutaj pokusić się o zastosowanie szablonów ( C++ 17 ).

#include <iostream>

using namespace std;

template< typename... Args >
class Abstract
{
public:
    virtual void create( Args... ) = 0;
};

template< typename... Args >
class A : public Abstract< Args... >
{
public:
    void create( Args... items ) override { ( (cout << items << "  " ) , ... ); };
};

int main()
{
    A<bool,float,int> foo;

    foo.create(true,23.5,7);

    return 0;
}

Jednakże takie podejście wydaje mi się niepotrzebnie skompilowane w porównaniu do polimorfizmu i ma ograniczenie do możliwości nadpisania tylko jednej funkcji (może da się to jakość obejść?).
Generalnie interfejs powinien dokładnie definiować sygnaturę funkcji implementowanych w klasach pochodnych.