Сопоставление класса перечисления с перегрузкой функции

В функции шаблона вы можете иметь один массив для каждого вызывающего элемента.

class Algorithms {
    Type1 memfunc1() { return 1; }
    Type1 memfunc1(const Type2&) { return 1; }
    Type1 memfunc1(Type3&, const Type2&) { return 1; }
    Type1 memfunc2() { return 2; }
    Type1 memfunc2(const Type2&) { return 2; }
    Type1 memfunc2(Type3&, const Type2&) { return 2; }
    Type1 memfunc3() { return 3; }
    Type1 memfunc3(const Type2&) { return 3; }
    Type1 memfunc3(Type3&, const Type2&) { return 3; }
        
    template<typename... Args>
    Type1 caller(Algos algo, Args... args) {
        static constexpr std::array<Type1(Algorithms::*)(Args...), std::to_underlying(Algos::NUM_OF_FUNCTIONS)> dispatch = { &Algorithms::memfunc1, &Algorithms::memfunc2, &Algorithms::memfunc3 };
        return std::invoke(dispatch[std::to_underlying(algo)], this, args...); 
    }
        
public:
    Type1 caller1(Algos algo) { 
        return caller<>(algo);
    }
    Type1 caller2(const Type2& arg, Algos algo) { 
        return caller<const Type2&>(algo, arg);
    }
    Type1 caller3(Type3& arg1, const Type2& arg2, Algos algo) { 
        return caller<Type3&, const Type2&>(algo, arg1, arg2);
    }
};

Я бы рекомендовал организовать так:

class Algorithm
{
public:
    virtual Type1 memfunc() = 0;
    virtual Type1 memfunc(const Type2&)  = 0;....
};
class Algorithm1: public Algorithm
{
public:
    virtual Type1 memfunc();
    virtual Type1 memfunc(const Type2&); ....
};
class Algorithm2: public Algorithm
{
public:
    virtual Type1 memfunc();
    virtual Type1 memfunc(const Type2&); ....
};
...

...
class Algorithms
{
...
    // static just for simplicity, not required really
    static Algoritm argorithms[3] = {new Algorithm1(), new Algoritm2(), ...};
//wrap und encapsulate
};

Идея состоит в том, чтобы вызвать вот так

Algos algo = FUN1;
Type1 x = Algoritms::alborithms[algo]->memfunc(...);

Если вы разобьете класс на более мелкие части, представляющие отдельные алгоритмы, то вы сможете использовать std::variant для большей части механизмов (что дружественно к constexpr) и сохранить локализацию своего собственного переключателя.

class Algorithms;
struct Algo1 {
    Type1 memfunc(Algorithms*);
    Type1 memfunc(Algorithms*, const Type2&);
    Type1 memfunc(Algorithms*, Type3&, const Type2&);
};

struct Algo2 {
    Type1 memfunc(Algorithms*);
    Type1 memfunc(Algorithms*, const Type2&);
    Type1 memfunc(Algorithms*, Type3&, const Type2&);
};

// ...

class Algorithms {
    using Impl = std::variant<Algo1, Algo2, ...>;
    static constexpr Impl ImplForAlgo(Algos a) {
        switch(a) {
          case Algos::FUN1: return Impl(std::in_place_index<0>);
          case Algos::FUN2: return Impl(std::in_place_index<1>);
          case Algos::FUN3: return Impl(std::in_place_index<2>);
        }
        throw std::bad_variant_access();
    }

public:
    Type1 caller1(Algos algo) { 
        return std::visit<Type1>([this](auto&& a){
            return a.memfunc(this);
        }, ImplForAlog(algo))
    }
    Type1 caller2(const Type2& arg, Algos algo) { 
        return std::visit<Type1>([this, &arg](auto&& a){
            return a.memfunc(this, arg);
        }, ImplForAlog(algo))
    }
    Type1 caller3(Type3& arg1, const Type2& arg2, Algos algo) { 
        return std::visit<Type1>([this, &arg1, &arg2](auto&& a){
            return a.memfunc(this, arg1, arg2);
        }, ImplForAlog(algo))
    }

};

Я передал Algorithms* явно на случай, если в отдельных алгоритмах понадобится какое-то состояние из старого монолита. Но если нет, то полученный код будет еще более кратким.

template<auto x>
using val_t = std::integral_constant<decltype(x), x>;

template<auto x>
constexpr val_t<x> val_k = {};

это ценности как типы и моногосударства. Это полезно тем, что с его помощью вы можете конвертировать перечисления в варианты.

template<auto...Xs>
using venum_t = std::variant< val_t<Xs>... >;

a venum_t — это вариант списка значений в качестве моногосударства.

using vAlgos = venum_t<Algos::FUN1, Algos::FUN2, Algos::FUN3>;

vAlgos — это оболочка венума вокруг перечисления Algos. Мы можем автоматизировать его генерацию (используя Algos::NUM_OF_FUNCTIONS и предполагая смежность).

Во время выполнения vAlgos является целым числом, значение которого соответствует значению времени выполнения перечисления Algos (0, 1, 2). Но мы можем использовать std::apply, чтобы получить значение как константу времени компиляции! Более того, мы можем преобразовать значения времени выполнения в значения времени компиляции следующим образом:

template<class E, E... Xs, class R=venum_t<Xs...> >
R make_venum( E x ) {
  using f_t = R(*)();
  f_t table[] = {
    +[]()->R {
      return R(std::in_place_type_t<val_t<Xs>>{});
    }...
  };
  return table[ std::underlying_type_t<E>(x) ]();
}

сейчас

vAlgos make_vAlgos( Algos a ) {
  return make_venum<Algos, Algos::FUN1, Algos::FUN2, Algos::FUN3>( a );
}

принимает значение времени выполнения Algos и создает variant моносостояния времени компиляции. (Написание этой функции также можно автоматизировать, я пишу ее вручную, чтобы было проще).

Что мы получаем от всего этого шума?

template<Algos algo, class...Ts>
auto memfunc_caller(val_t<algo>, Ts&&...ts) {
  if constexpr (algo == Algos::FUN1) {
    return memfun1(std::forward<Ts>(ts)...);
  } else if constexpr (algo == Algos::FUN2) {
    return memfun2(std::forward<Ts>(ts)...);
  } else if constexpr (algo == Algos::FUN3) {
    return memfun3(std::forward<Ts>(ts)...);
  }
};

мы тогда делаем

template<class...Ts>
Type1 Algorithms::caller( vAlgos valgo, Ts&&... ts ) {
  return std::visit([&](auto algo){
    return memfunc_caller(algo, std::forward<Ts>(ts)...);
  }, valgo);
}

template<class...Ts>
Type1 Algorithms::caller( Algos algos, Ts&&... ts ) {
  return caller( make_vAlgos(algos), std::forward<Ts>(ts)... );
}

обратите внимание, что передача vAlgos вместо Algos экономит часть работы по преобразованию.

Мы можем упростить это до 1 или 2 функций, если вам не нужна вся мощь вариантов над перечислениями.