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

avenum_t是单态值列表的变体。

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

vAlgos是枚举的 venum 包装器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 个函数。

我建议像这样组织：

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*明确地传递了这一点，以防个别算法需要旧整体中的任何状态。但如果不需要，生成的代码会更加简洁。