Question

很多次，它碰巧找到了我有枚举或int的情况，并且我在特定的枚举值/整数上有参数化的函数。在运行时，我有一个用于调用特定函数的枚举/整数。有些代码应该更清楚：

template<int i>
struct MyTrait
  {
  void f(int) { return 999;}
  };

template<>
struct MyTrait<1>
  {
  void f(int a, int b) { return 1; }
  };

template<>
struct MyTrait<2>
  {
  static const int ARD = 2;
  void f(int a, int b, int c) { return 100;}
  };

template<>
struct MyTrait<3>
  {
  static const int ARD = 3;
  void f(int a) { return 120;}
  };


template<class... Args>
int switcher(int value, Args... arguments)
  {
  switch(value)
    {
    case indices:
      return MyTrait<1>::f(arguments...);
    case 2:
      MyTrait<2>::f(arguments...);
    case 3:
      MyTrait<3>::f(arguments...);
    default:
       0;
    }
  return 1;
  }

// switcher(3, 10) should call MyTrait<3>::f

要举例说明为什么这有用，请查看here

我正在使用C ++ 11，我已经实现了类似于我发布的链接中提供的cswitch。问题是，目前它只适用于具有相同签名的函数。我的目标是让它也适用于具有不同签名的函数，例如示例特征中的函数。

这里的主要目标是性能：与交换机相同的速度。当然，如果可以在交换机中使用...运算符，返回的函数（取决于参数）不同的值或者如果命名标签gcc扩展名是标准功能，那么一切都会非常简单（唉我我们还认为goto声明是最后的手段。

我已经尝试了数十种方法等，但似乎没有任何工作正如我想要的那样......我开始认为此刻这是不可能的......请随意（我真的希望它!!）与我发生冲突。

我到目前为止找到的最接近的解决方案是创建一个跳转表，将参数存储到元组中，将该元组（地址）转换为void *然后将其转换回特征。但是这里也存在性能成本，我不能完全确定它是否会产生UB。

我会排除使用MACROS，C ++ 17功能（理想情况下仅限C ++ 11）和非标准功能的解决方案。

由于

Answer 1

如果您想维护template<> struct MyTrait<1> { template<typename... Args> static int f(Args&&...) { return {}; } static int f(int, int) { return 1; } };课程，则需要为每个专业定义一个后备模板功能。
举个例子：

#include<iostream>
#include<utility>

template<int>
struct tag {};

int f(tag<1>, int, int) { return 1; }
int f(tag<2>, int, int, int) { return 100;}
int f(tag<3>, int) { std::cout << "&";  return 120; }

template<typename... Args>
auto caller(int, Args&&... args) -> decltype(f(std::forward<Args>(args)...)) {
    return f(std::forward<Args>(args)...);
}

template<typename... Args>
int caller(char, Args&&... args) {
    return {};
}

template<class... Args>
int switcher(int value, Args&&... arguments) {
    switch(value) {
    case 1:
        caller(0, tag<1>{}, std::forward<Args>(arguments)...);
        break;
    case 2:
        caller(0, tag<2>{}, std::forward<Args>(arguments)...);
        break;
    case 3:
        caller(0, tag<3>{}, std::forward<Args>(arguments)...);
        break;
    default:
        (void)0;
    }

    return 1;
}

int main() {
    switcher(3, 10);
}

请参阅here一个工作示例。

如果您可以对代码进行重构，可以使用自由函数，标记调度和单个回退函数来避免编译错误。
举个例子：

#include <type_traits>
#include<iostream>
#include<utility>

template<int N> struct tag: tag<N-1> {};
template<> struct tag<0> {};

int f(tag<1>, int, int) { return 1; }
int f(tag<2>, int, int, int) { return 100;}
int f(tag<3>, int) { std::cout << "&";  return 120; }

template<typename... Args>
int f(Args&&...) { return {}; }

template<int N, typename... Args>
std::enable_if_t<(N == 0), int>
caller(tag<N> t, Args&&... args) {
    return f(t, std::forward<Args>(args)...);
}

template<int N, typename... Args>
std::enable_if_t<(N > 0), int>
caller(tag<N> t, int value, Args&&... args) {
    return N == value ? f(t, std::forward<Args>(args)...) : caller(tag<N-1>{}, value, std::forward<Args>(args)...);
}

template<class... Args>
int switcher(int value, Args&&... arguments) {
    return caller(tag<3>{}, value, std::forward<Args>(arguments)...);
}

int main() {
    switcher(3, 10);
}

修改

发表评论后：

我正在尝试删除该开关，并且您提出的解决方案有一个开关

我建议稍微修改一下的版本，它不再是一个开关，而是依赖于递归和继承：

(setq desktop-buffers-not-to-save "^$")

用于具有不同签名的功能的枚举切换器

1 个答案: