c++ - 如何按类型从 std::tuple 获取元素

Question

我有一组 A、B、C 类，我想按类型从通用代码访问它们的实例，fe

template<typename T>
newObject()
{
    return m_storage->getNew();
}

其中 m_storage 是 A 或 B 或 C 的实例，取决于 T。

所以我想出了std::tuple，但是有问题因为我不能按类型从元组中获取元素。

std::tuple<A,B,C> m_tpl;
template<typename T>
newObject()
{
    return m_tpl.get<T>().getNew();
}

有什么办法吗？这可能吗？

谢谢。

PS：我不想为每种类型编写 newObject 的特化。:-)

Answer 1

这是 C++14 中关于按类型从元组中获取值的草稿。

但在 C++14 到来之前，您可以编写如下内容：

namespace detail
{

template <class T, std::size_t N, class... Args>
struct get_number_of_element_from_tuple_by_type_impl
{
    static constexpr auto value = N;
};

template <class T, std::size_t N, class... Args>
struct get_number_of_element_from_tuple_by_type_impl<T, N, T, Args...>
{
    static constexpr auto value = N;
};

template <class T, std::size_t N, class U, class... Args>
struct get_number_of_element_from_tuple_by_type_impl<T, N, U, Args...>
{
    static constexpr auto value = get_number_of_element_from_tuple_by_type_impl<T, N + 1, Args...>::value;
};

} // namespace detail

template <class T, class... Args>
T get_element_by_type(const std::tuple<Args...>& t)
{
    return std::get<detail::get_number_of_element_from_tuple_by_type_impl<T, 0, Args...>::value>(t);
}

int main()
{
    int a = 42;

    auto t = std::make_tuple(3.14, "Hey!", std::ref(a));

    get_element_by_type<int&>(t) = 43;

    std::cout << a << std::endl;

    // get_element_by_type<char>(t); // tuple_element index out of range

    return 0;
}

Answer 2

一个简单的可变参数 mixin 容器就可以解决问题：

template < typename T > struct type_tuple_value 
{ 
    T value; 
    type_tuple_value ( T&& arg ) : value(std::forward<T>(arg)) {}
};

template < typename ...T > struct type_tuple : type_tuple_value<T>...
{
    template < typename ...Args > type_tuple ( Args&&... args ) :
    type_tuple_value<T>(std::forward<T>(args))... {}
    template < typename U > U& get() { return type_tuple_value<U>::value; }
    template < typename U > const U& get() const { return type_tuple_value<U>::value; }
};

例子

Answer 3

如果您不喜欢模板，也可以使用 constexpr 函数计算类型的位置。

  constexpr int count_first_falses() { return 0; }

  template <typename... B>
  constexpr int count_first_falses(bool b1, B... b)
  {
    if (b1) return 0;
    else return 1 + count_first_falses(b...);
  }

  template <typename E, typename... T>
  decltype(auto) tuple_get_by_type(const std::tuple<T...>& tuple)    
  {
    return std::get<count_first_falses((std::is_same<T, E>::value)...)>(tuple);
  }