在可变参数模板上生成变量列表

问题描述

在C ++ 17和更高版本中，可以这样将结构分解为变量：

struct MyStruct
{
    int f1;
    int f2;
    int f3;
};
auto& [f1,f2,f3] = my_struct;

我正试图在可变参数包函数中做到这一点，

template <class ... T,std::size_t...I>
constexpr std::size_t CountFields(std::index_sequence<I...>)
{
    T t;
    auto& [] = t;
    return 0;
}

但是我不完全确定如何填充方括号之间的空间以获取变量。最终目标是使用这些变量创建一个元组（即，我正在尝试创建一个通用的元组函数结构）。我发现与此最接近的是：struct to/from std::tuple conversion。

但是出于多种原因，我需要避免使用BOOST。

解决方法

不幸的是，很显然，没有办法在结构化绑定中使用参数包。另一方面，如果没有结构化绑定，就无法绑定数据成员。

但是，如果您提供数据成员的数量，则可以通过传统方式将其绑定：

template<size_t>
struct structToTupleHelper;

template<>
struct structToTupleHelper<0>; // ISO C++17 does not allow a decomposition group to be empty.

template<>
struct structToTupleHelper<1>{
    template<typename X,size_t... Is>
    static auto convert(X&& x,std::index_sequence<Is...>){
        auto&& [a1] = std::forward<X>(x); // bound variables are always thought as lvalue.
        auto temp = std::forward_as_tuple(a1);
        return std::forward_as_tuple(std::get<Is>(temp)...);
    }
};

template<>
struct structToTupleHelper<2>{
    template<typename X,std::index_sequence<Is...>){
        auto&& [a1,a2] = std::forward<X>(x); // bound variables are always thought as lvalue.
        auto temp = std::forward_as_tuple(a1,a2);
        return std::forward_as_tuple(std::get<Is>(temp)...);
    }
};

// ...
// maybe 16 is enough?

template<typename X,size_t... Is>
auto structToTuple(X&& x,std::index_sequence<Is...> _1){
    return structToTupleHelper<sizeof...(Is)>::convert(std::forward<X>(x),_1);
}

template<size_t N,typename X,std::index_sequence<Is...> _1){
    return structToTupleHelper<N>::convert(std::forward<X>(x),typename X>
auto structToTuple(X&& x){
    return structToTupleHelper<N>::convert(std::forward<X>(x),std::make_index_sequence<N>());
}

，然后您可以使用它，例如：

int ii;
struct A{
    int& a;
} a{ii};
struct B{
    int a;
} b;

auto t1 = structToTuple<1>(A{ii}); // tuple<int&>,valid.
auto t2 = structToTuple<1>(a);     // tuple<int&>,valid.
auto t3 = structToTuple<1>(B{});   // tuple<int&>,invalid: a lvalue reference is bound to a temporary object.
auto t4 = structToTuple<1>(b);     // tuple<int&>,valid.
somefunc(structToTuple<1>(B{})); // valid. the temporary object is alive inside 'somefunc'.
structToTuple<1>(A{ii}) = std::tuple(1); // valid. assign 1 to 'ii'.
structToTuple<1>(a) = std::tuple(1);     // valid. assign 1 to 'ii'.
structToTuple<1>(B{}) = std::tuple(1);   // unexpected. assign 1 to the member of a temporary object.
structToTuple<1>(b) = std::tuple(1);     // valid. assign 1 to 'b.a'.

// struct C{
//     int a : 8;
// } c;
// auto t5 = structToTuple<1>(C{}); // invalid: bitfields can not be treated as non-const lvalue reference
// auto t6 = structToTuple<1>(c);   // invalid: bitfields can not be treated as non-const lvalue reference

也许您认为进行专业化很麻烦。幸运的是，我们可以使用宏来简化它：（这正是BOOST始终所做的。）

#define XXX_CONCAT_HELPER(a,b) a##b
#define XXX_CONCAT(a,b) XXX_CONCAT_HELPER(a,b)

#define XXX_COMMA,#define XXX_COMMA_FUNC(a),#define XXX_EMPTY
#define XXX_EMPTY_FUNC(a)

#define XXX_REPEAT_0(func,join)
#define XXX_REPEAT_1(func,join) func(1)
#define XXX_REPEAT_2(func,join) XXX_REPEAT_1(func,join) join(2) func(2)
// ...
#define XXX_REPEAT_256(func,join) XXX_REPEAT_255(func,join) join(256) func(256)

#define XXX_REPEAT(func,times,join) XXX_CONCAT(XXX_REPEAT_,times)(func,join)

// macro is not allowed to be recursive,so we need another repeat function.
#define XXX_ALIAS_REPEAT_0(func,join)
#define XXX_ALIAS_REPEAT_1(func,join) func(1)
#define XXX_ALIAS_REPEAT_2(func,join) XXX_ALIAS_REPEAT_1(func,join) join(2) func(2)
// ...
#define XXX_ALIAS_REPEAT_256(func,join) XXX_ALIAS_REPEAT_255(func,join) join(256) func(256)

#define XXX_ALIAS_REPEAT(func,join) XXX_CONCAT(XXX_ALIAS_REPEAT_,join)

#define STRUCT_TO_TUPLE_TOKEN_FUNC(n) XXX_CONCAT(a,n)

#define STRUCT_TO_TUPLE_FUNC(n) \
template<> \
struct structToTupleHelper<n>{ \
    template<typename X,size_t... Is> \
    static auto convert(X&& x,std::index_sequence<Is...>){ \
        auto&& [XXX_REPEAT(STRUCT_TO_TUPLE_TOKEN_FUNC,n,XXX_COMMA_FUNC)] = std::forward<X>(x); \
        auto temp = std::forward_as_tuple(XXX_REPEAT(STRUCT_TO_TUPLE_TOKEN_FUNC,XXX_COMMA_FUNC)); \
        return std::forward_as_tuple(std::get<Is>(temp)...); \
    } \
}; \


XXX_ALIAS_REPEAT(STRUCT_TO_TUPLE_FUNC,128,XXX_EMPTY_FUNC)

#undef STRUCT_TO_TUPLE_TOKEN_FUNC
#undef STRUCT_TO_TUPLE_FUNC