使结构表现得像std :: tuple

Question

我写了一些通用的代码来管理元组列表。 现在，我想使用该代码，但我想使用简单的结构而不是std::tuple ，因此我可以使用名称而不是索引来访问变量。 有没有一种简单的方法可以使这些结构像std::tuple ，因此我可以将其与通用代码一起使用？

struct foo {
    int x;
    float y;

    // some code to enable tuple like behavior (e.g. std::get, std::tuple_size)
};

我尝试添加一个as_tuple成员函数，该函数使用std::tie返回所有成员。 这可行，但是需要在需要元组行为的所有地方调用此成员函数。

Answer 1

手动方式：

struct foo {
    int x;
    float y;
};


namespace std
{

    template <>
    class tuple_element<0, foo> {
        using type = int;
    };

    template <>
    class tuple_element<1, foo> {
        using type = float;
    };

    template <std::size_t I>
    tuple_element_t<I, foo>& get(foo&);

    template <>
    tuple_element_t<0, foo>& get(foo& f) { return f.x;}

    template <>
    tuple_element_t<1, foo>& get(foo& f) { return f.y; }

    template <std::size_t I>
    tuple_element_t<I, foo> get(const foo&);

    template <>
    tuple_element_t<0, foo> get(const foo& f) { return f.x;}

    template <>
    tuple_element_t<1, foo> get(const foo& f) { return f.y; }
}

另一种方法是编写函数as_tuple ：

template <typename ... Ts>
std::tuple<Ts...>& as_tuple(std::tuple<Ts...>& tuple) { return tuple; }

std::tuple<int&, float&> as_tuple(foo& f) { return std::tie(f.x, f.y); }

并在使用类似元组的方法之前包装好电话。

Answer 2

首先， as_tuple应该是类名称空间中的自由函数。 这使您可以扩展其他人编写的类型。

接下来，您应该尝试在启用ADL的上下文中调用get 。

using std::get;
auto& x = get<1>(foo);

如果这样做，我们可以发挥一些魔力。

struct get_from_as_tuple {
  template<std::size_t I,
    class T,
    std::enable_if_t< std::is_base_of< get_from_as_tuple, std::decay_t<T> >, bool > = true
  >
  friend decltype(auto) get( T&& t ) {
    return std::get<I>( as_tuple( std::forward<T>(t) ) );
  }
};

现在

struct foo:get_from_as_tuple {
  int x;
  float y;

  friend auto as_tuple( get_from_as_tuple const& self ) {
    return std::tie( self.x, self.y );
  }
};

我们做得到：

foo f;
using std::get;
std::cout << get<0>(f) << "," << get<1>(f) << "\n";

现在，这仍然不会启用tuple_size和tuple_element 。

没有简单的方法可以做到这一点，但是我们可以解决它。

#define RETURNS(...) \
  noexcept(noexcept(__VA_ARGS__)) \
  -> decltype(__VA_ARGS__) \
  { return __VA_ARGS__; }

namespace tup {
  namespace adl_get {
    using std::get;
    template<std::size_t I,
      class T
    >
    auto get_helper( T&& t )
    RETURNS( get<I>(std::forward<T>(t) ) )
  }
  template<std::size_t I, class T>
  auto get( T&& t )
  RETURNS(adl_get::get_helper<I>(std::forward<T>(t)))
}

现在tup::get<7>( x )就会分派到无论是std::get或另一get在x的命名空间基于关的重载决策规则。

我们可以创建类似的助手：

namespace util {
  template<class T>
  struct tag_t {constexpr tag_t(){}};
  template<class T>
  constexpr tag_t<T> tag{};
}
namespace tup {
  namespace adl_tuple_size {
    template<class T>
    constexpr std::size_t get_tuple_size( tag_t<T>, ... ) {
      return std::tuple_size<T>::value;
    }
    template<class T>
    constexpr auto get_tuple_size( tag_t<T>, int )
    RETURNS( tuple_size( tag_t<T> ) )
  }
  template<class T>
  constexpr std::size_t tuple_size() {
    return adl_tuple_size::get_tuple_size( tag<T> );
  }
}

现在tup::tuple_size<Foo>()是一个constexpr呼叫得到的大小Foo通过（A）调用tuple_size( tag_t<Foo> )在启用ADL-上下文中，或（B）返回std::tuple_size<Foo>::value 。

一旦有了这个，我们就可以创建另一个helper基本类型：

struct tuple_size_from_as_tuple {
  template<std::size_t I,
    class T,
    std::enable_if_t< std::is_base_of< get_from_as_tuple, std::decay_t<T> >, bool > = true
  >
 friend std::size_t tuple_size( T&& t ) {
    return std::tuple_size< decltype(as_tuple( std::forward<T>(t) ) ) >::value;
  }
};

struct as_tuple_helpers : get_from_as_tuple, tuple_size_from_as_tuple {};

struct foo:as_tuple_helpers {
  // ..
};

现在我们有2个原语。

对tag_t<E&> tuple_element( tag_t<T> )重复此tag_t<E&> tuple_element( tag_t<T> ) 。 然后，我们可以编写一个tup::tuple_element<T, 0>别名，您可以根据自己的tup::tuple_element<T, 0>进行调度。

最后，修改与std:: tuple设施一起使用的现有代码以使用tup tup::设施。 它应与现有工作tuple代码，并且还将与来自继承工种as_tuple_helper具有friend as_tuple定义。

但是，这不支持结构化绑定。