7

是否可以使用结构化绑定语法来确定我应该在方括号中指定多少个变量名称以匹配普通右侧的数据成员数struct？

我想成为通用库的一部分，它使用结构化绑定将任意类分解为其组成部分。目前没有结构化绑定的可变参数版本（而且，我认为，不能用于当前提出的语法），但我的第一个想法是对一些函数进行一组重载decompose()，它将参数分解struct为一组它的成分。decompose()应该被参数的（即struct）数据成员的数量重载。目前constexpr if 语法也可以用来调度这个。但是为了上述目的，我怎样才能模拟类似于sizeof...operator 的东西呢？我不能auto [a, b, c]在 SFINAE 结构中的某处使用语法，因为它是一个分解声明并且 AFAIK 任何声明都不能在里面使用decltype，我也不能在 lambda 函数的主体中使用它，因为 lambda 函数也不能在模板参数中使用。

当然，我想要内置运算符（使用类似sizeof[] S/ sizeof[](S)for的语法class S），但也可以接受以下内容：

template< typename type, typename = void >
struct sizeof_struct
{

};

template< typename type >
struct sizeof_struct< type, std::void_t< decltype([] { auto && [p1] = std::declval< type >(); void(p1); }) > >
    : std::integral_constant< std::size_t, 1 >
{

};

template< typename type >
struct sizeof_struct< type, std::void_t< decltype([] { auto && [p1, p2] = std::declval< type >(); void(p1); void(p2);  }) > >
    : std::integral_constant< std::size_t, 2 >
{

};

... etc up to some reasonable arity

也许constexprlambda 将允许我们将它们用于模板的参数。你怎么看？

未来的概念是否有可能？

4

2 回答 2

9 
struct two_elements {
  int x;
  double y;
};

struct five_elements {
  std::string one;
  std::unique_ptr<int> two;
  int * three;
  char four;
  std::array<two_elements, 10> five;
};

struct anything {
  template<class T> operator T()const;
};

namespace details {
  template<class T, class Is, class=void>
  struct can_construct_with_N:std::false_type {};

  template<class T, std::size_t...Is>
  struct can_construct_with_N<T, std::index_sequence<Is...>, std::void_t< decltype(T{(void(Is),anything{})...}) >>:
  std::true_type
  {};
}
template<class T, std::size_t N>
using can_construct_with_N=details::can_construct_with_N<T, std::make_index_sequence<N>>;

namespace details {
  template<std::size_t Min, std::size_t Range, template<std::size_t N>class target>
  struct maximize:
    std::conditional_t<
      maximize<Min, Range/2, target>{} == (Min+Range/2)-1,
      maximize<Min+Range/2, (Range+1)/2, target>,
      maximize<Min, Range/2, target>
    >
  {};
  template<std::size_t Min, template<std::size_t N>class target>
  struct maximize<Min, 1, target>:
    std::conditional_t<
      target<Min>{},
      std::integral_constant<std::size_t,Min>,
      std::integral_constant<std::size_t,Min-1>
    >
  {};
  template<std::size_t Min, template<std::size_t N>class target>
  struct maximize<Min, 0, target>:
    std::integral_constant<std::size_t,Min-1>
  {};

  template<class T>
  struct construct_searcher {
    template<std::size_t N>
    using result = ::can_construct_with_N<T, N>;
  };
}

template<class T, std::size_t Cap=20>
using construct_airity = details::maximize< 0, Cap, details::construct_searcher<T>::template result >;

这会对从 0 到 20 的最长构造通风进行二分搜索T。20 是一个常数，您可以在编译时和内存成本上随意增加它。

活生生的例子。

如果你的结构中的数据不能从它自己类型的右值构造，它不会在 C++14 中工作，但我相信在 C++17 中会发生 guanteed elision (!)

将其转换为结构化绑定需要的不仅仅是一堆手动代码。但是一旦你有了，你应该能够问诸如“这是什么第三种类型struct”之类的问题。

如果 astruct可以在不做任何tuple_size事情的情况下分解为结构化绑定，那么它的空气流通性决定了它需要多少变量。

不幸std::tuple_size的是，即使在 C++17 中也对 SFINAE 不友好。但是，使用该tuple_size部分的类型也需要启用 ADL std::get。

failure_tag get<std::size_t>(Ts const&...)使用that创建一个命名空间using std::get。使用它来检测它们是否已经覆盖get<0>了类型 ( !std::is_same< get_type<T,0>, failure_tag >{})，如果是，则沿着tuple_element路径确定通风。将结果元素填充到 a std::tupleof 中decltype(get<Is>(x))并返回它。

如果失败，请使用上述construct_airity方法，并使用它来确定如何在类型上使用结构化绑定。std::tie为了统一起见，我可能会将其发送到, 中。

我们现在有了tuple_it它，它接受任何类似结构化绑定的东西并将其转换为引用或值的元组。现在两条路径已经融合，您的通用代码更容易了！

于 2016-09-29T20:35:41.260 回答
1

还有一种线性方法可以找到“聚合数量”（尽管在同样严格的情况下，如接受的答案）：

#include <type_traits>
#include <utility>
#include <tuple>

struct filler { template< typename type > operator type && (); };

template< typename aggregate, 
          typename index_sequence = std::index_sequence<>, 
          typename = void >
struct aggregate_arity
        : index_sequence
{

};

template< typename aggregate, 
          std::size_t ...indices >
struct aggregate_arity< aggregate, 
                        std::index_sequence< indices... >, 
                        std::void_t< decltype(aggregate{(indices, std::declval< filler >())..., std::declval< filler >()}) > >
    : aggregate_arity< aggregate, 
                       std::index_sequence< indices..., sizeof...(indices) > >
{

};

template< std::size_t index, typename type >
constexpr
decltype(auto)
get(type & value) noexcept
{
    constexpr std::size_t arity = aggregate_arity< std::remove_cv_t< type > >::size();
    if constexpr (arity == 1) {        
        auto & [p1] = value;
        if constexpr (index == 0) {
            return (p1);
        } else {
            return;
        }
    } else if constexpr (arity == 2) {
        auto & [p1, p2] = value;
        if constexpr (index == 0) {
            return (p1);
        } else if constexpr (index == 1) {
            return (p2);
        } else {
            return;
        }
    } else if constexpr (arity == 3) {
        auto & [p1, p2, p3] = value;
        if constexpr (index == 0) {
            return (p1);
        } else if constexpr (index == 1) {
            return (p2);
        } else if constexpr (index == 2) {
            return (p3);
        } else {
            return;
        }
    } else /* extend it by yourself for higher arities */ {
        return;
    }
}

// main.cpp
#include <cstdlib>
#include <cassert>

namespace
{

using S = struct { int i; char c; bool b; };

S s{1, '2', true};

decltype(auto) i = get< 0 >(s);
decltype(auto) c = get< 1 >(s);
decltype(auto) b = get< 2 >(s);

static_assert(std::is_same< decltype(i), int & >{});
static_assert(std::is_same< decltype(c), char & >{});
static_assert(std::is_same< decltype(b), bool & >{});

static_assert(&i == &s.i);
static_assert(&c == &s.c);
static_assert(&b == &s.b);

}

int
main()
{
    assert(i == 1);
    assert(c == '2');
    assert(b == true);
    return EXIT_SUCCESS;
}

由于bug的原因，当前的参数get()不能具有const顶级类型限定符（即type可以是&&and &，但不是const &and ） 。const &&

活生生的例子。

于 2016-09-30T05:03:35.507 回答