У меня есть переменная i типа std::size_t и кортеж типа std::tuple. Я хочу получить i -й элемент кортежа. Я пробовал это:
// bindings... is of type const T&...
auto bindings_tuple = std::make_tuple(bindings...);
auto binding = std::tuple_element<i, const T&...>(bindings_tuple);
Но я получаю эту ошибку компиляции, говоря, что первый аргумент шаблона должен быть интегральным постоянным выражением:
error: аргумент шаблона типа типа <
std::size_t'(aka'unsigned long') не является интегральным постоянным выражением
Можно ли получить i -й элемент кортежа и как это сделать?
Я хотел бы сделать это без использования boost, если это возможно.
Вы не можете. Это не для кортежа. Если вам нужен динамический доступ к элементу, используйте std::array<T,N>, который почти идентичен std::tuple<T,...,T>, но дает динамический [i] -оператор; или даже полностью динамический контейнер, например std::vector<T>.
Это возможно:
struct Functor
{
template<typename T>
void operator()(T& t) const { std::cout << t << std::endl; }
};
template<std::size_t I = 0, typename FuncT, typename... Tp>
inline typename std::enable_if<I == sizeof...(Tp), void>::type
for_index(int, std::tuple<Tp...> &, FuncT)
{ }
template<std::size_t I = 0, typename FuncT, typename... Tp>
inline typename std::enable_if<I < sizeof...(Tp), void>::type
for_index(int index, std::tuple<Tp...>& t, FuncT f)
{
if (index == 0) f(std::get<I>(t));
for_index<I + 1, FuncT, Tp...>(index-1, t, f);
}
auto t = make_tuple(1, 2, "abc", "def", 4.0f);
int i = 2; // for example
for_index(i, t, Functor());
Этот код напечатает:
ABC
Рабочий пример на идеоне: образец
Это, вероятно, не то, что хочет OP, но в любом случае, можно вернуть i-й элемент с использованием времени выполнения i, если вы возвращаете тип варианта, например boost::variant или boost::any,
#include <tuple>
#include <stdexcept>
#include <boost/variant.hpp>
template <size_t n, typename... T>
boost::variant<T...> dynamic_get_impl(size_t i, const std::tuple<T...>& tpl)
{
if (i == n)
return std::get<n>(tpl);
else if (n == sizeof...(T) - 1)
throw std::out_of_range("Tuple element out of range.");
else
return dynamic_get_impl<(n < sizeof...(T)-1 ? n+1 : 0)>(i, tpl);
}
template <typename... T>
boost::variant<T...> dynamic_get(size_t i, const std::tuple<T...>& tpl)
{
return dynamic_get_impl<0>(i, tpl);
}
Например:
#include <string>
#include <iostream>
int main()
{
std::tuple<int, float, std::string, int> tpl {4, 6.6, "hello", 7};
for (size_t i = 0; i < 5; ++ i)
std::cout << i << " = " << dynamic_get(i, tpl) << std::endl;
return 0;
}
напечатает:
0 = 4 1 = 6.6 2 = hello 3 = 7 terminate called after throwing an instance of 'std::out_of_range' what(): Tuple element out of range. Aborted
(Для boost::variant<T...> требуется g++ 4.7)
Вопрос здесь, каким будет тип возвращаемого типа, если это будет возможно? Он должен быть известен во время компиляции, но кортеж может содержать элементы разных типов.
Предположим, что у нас есть набор из трех элементов:
auto tuple = std::make_tuple(10, "", A());
using tuple_type = decltype(tuple);
По-видимому, получение N-го элемента не имеет большого смысла. Какой бы он был? Он не известен до времени выполнения. Однако вместо того, чтобы получать N-й элемент, вы можете применить к нему функцию, учитывая, что все элементы поддерживают некоторый общий протокол:
void process(int n)
{
if (n == 0)
func(std::get<0>(tuple));
else if (n == 1)
func(std::get<1>(tuple));
else if (n == 2)
func(std::get<2>(tuple));
}
Этот код "динамически" обрабатывает элемент, учитывая индекс n. Общим протоколом в этом примере является функция func, которая может сделать что-то значимое со всеми возможными типами, используемыми в кортеже.
Однако писать такой код вручную - это утомительно, мы хотим сделать его более общим. Начнем с извлечения функции приложения, поэтому мы можем повторно использовать одну и ту же функцию process для разных функторов:
template<template<typename > class F>
void process(int n)
{
if (n == 0)
{
using E = typename std::tuple_element<0, tuple_type>::type;
F<E>::apply(std::get<0>(tuple));
}
else if (n == 1)
{
using E = typename std::tuple_element<1, tuple_type>::type;
F<E>::apply(std::get<1>(tuple));
}
else if (n == 2)
{
using E = typename std::tuple_element<2, tuple_type>::type;
F<E>::apply(std::get<2>(tuple));
}
}
В этом случае F может быть реализовано как-то вроде:
// Prints any printable type to the stdout
struct printer
{
static void apply(E e)
{
std::cout << e << std::endl;
}
}
Давайте сделаем компилятор для создания всего этого кода, сделаем его общим:
constexpr static std::size_t arity = std::tuple_size<tuple_type>::value;
template<int N>
struct wrapper
{
template<template<typename, typename ... > class F>
static void apply_to(tuple_type& tuple, int idx)
{
if (idx)
// Double recursion: compile and runtime.
// Compile-time "recursion" will be terminated once
// we reach condition N == tuple arity
// Runtime recursion terminates once idx is zero.
wrapper<N + 1>::template apply_to<F>(tuple, idx - 1);
else
{
// idx == 0 (which means original index is equal to N).
using E = typename std::tuple_element<N, tuple_type>::type;
F<E>::apply(std::get<N>(tuple));
}
}
};
// Termination condition: N == arity.
template<>
struct wrapper<arity>
{
template<template<typename, typename ... > class F>
static void apply_to(tuple_type&, int)
{
// Throw exception or something. Index is too big.
}
};
Использование:
wrapper<0>::template apply_to<printer>(tuple, 2);
P.S. Я не настоящий разработчик на С++, поэтому вышеприведенный подход может быть полной бессмысленностью. Тем не менее, я счел это полезным для моего проекта микроконтроллера, где я хочу, насколько это возможно, решить во время компиляции и все же быть достаточно общим, чтобы я мог легко перемешать вещи. Например, "меню" в моем проекте в основном представляет собой набор "действий", каждое действие представляет собой отдельный класс, который поддерживает простой протокол, такой как "распечатать метку в текущей позиции на ЖК-дисплее" и "активировать и запускать петлю пользовательского интерфейса",.