在C中我有一个包含一些元素的元组：

std::tuple <int, char> my_tuple(3, 'q');

还有一些模板函数可以完美地用于整数和字符：

template <class T> void my_function(T);

现在,假设在运行时我想在我的元组的一个元素上运行my_function(但我不知道哪个).我注意到不可能做以下事情：

unsigned int n;

// Give a value to n

my_function(std::get <n> (my_tuple));

但是,原则上我需要的东西应该与以下内容完全相同：

unsigned int n;

// Give a value to n

switch(n)
{
    case 0:
      my_function(std::get <0> (my_tuple));
      break;
    case 1:
      my_function(std::get <1> (my_tuple));
      break;
    default:
      // Do nothing or throw an exception
}

所以这对我来说听起来应该是可行的……是吗？

解决方法:

n是运行时值,它不能用于在编译时实例化模板.您的开关有效,因为您手动实例化每个std :: get< N>,并将它们连接到相应的运行时值.

但是,是的,编写脑卒中开关树是一件苦差事.为什么不让编译器生成带有一点TMP的样板？

#include <tuple>
#include <cassert>
#include <iostream>

template <class T>
void my_function(T);

// Test specialisations to see what's going on
template <> void my_function(int i) { std::cout << "int " << i << '\n'; }
template <> void my_function(char c) { std::cout << "char " << c << '\n'; }

namespace detail {
    // Available in std in C++14
    template <bool P, class T>
    using enable_if_t = typename std::enable_if<P, T>::type;

    // Mockup function signature to pick up the call when enable_if shunts
    template <std::size_t N, class T = void>
    void callMyFunc(T&&, ...) {
        assert(!"Index not in range !");
    }

    // "Simple" recursive solution, removes itself from the overload set
    // to stop recursion
    template <std::size_t N, class... Ts,
        class = enable_if_t<N < sizeof...(Ts), void>>
    void callMyFunc(std::tuple<Ts...> &tuple, std::size_t n) {
        return n == N
            ? my_function(std::get<N>(tuple))
            : callMyFunc<N + 1>(tuple, n);
    }
}

// Tiny user-friendly wrapper
template <class... Ts>
void callMyFunc(std::tuple<Ts...> &tuple, std::size_t n) {
    detail::callMyFunc<0u>(tuple, n);
}

int main(int, char**) {
    std::tuple <int, char> my_tuple(3, 'q');

    // Success.
    callMyFunc(my_tuple, 0u);
    callMyFunc(my_tuple, 1u);

    return 0;
}