第十题，假如不使用结构化绑定的可能解法

[AzrBrk]

注：由于使用了大量的模板递归，使用了我自己的库， 但是理论上可以用这个库写出来东西的都可模板递归， 所有的头文件都是head only, 可以在这个仓库查看， 具体可参考while_constexpr：

#include"flex_string.hpp"
#include"exp_print.hpp"

using namespace flex_string;
using namespace flex_string_space;
using exp_print::meta_print;

namespace possibility
{
    //这个类型用来计算成员的个数
    struct Inits
    {
        template<class T> operator T();
    };
    //这个类型试探某种类型在某个位置是否可以构造
    //禁止隐式转换以得到正确的结果
    template<class T> struct convert_forbid
    {
        using type = T;
        template<
            class U,
            class En = std::enable_if_t<std::is_same_v<T, U>>
        > operator U();
    };
    //定义了一个元流的打断元函数，打断条件为，当可以构造成功时
    struct constructible_cond
    {
        template<class this_tl> struct apply
        {
            using tl = typename this_tl::to::type;
            using constructible_typelist = get_type<to_exp_list<tl>>::template to<std::is_constructible>;
            static constexpr bool value = constructible_typelist::value;
        };
    };

    template<class T>
    struct construct_list_ret_f
    {
        template<class TL> struct apply_impl { using type = no_exist_type; };

        template<template<class...> class TL, class First, class ...Rest> struct apply_impl<TL<First, Rest...>>
        {
            using type = exp_list<T, Rest...>;
        };
        template<class T> using apply = typename apply_impl<T>::type;
    };
   //元输出流，输出构造列表，比如is_constructible<T, X, Y>
    template<class TL,class T> using meta_construct_list_maker_decrease_istream =
        meta_ret_object<TL, common_object::decreased, construct_list_ret_f<T>>;

  
    //计算成员个数
    //support 20 members count by default
    template<class T> constexpr size_t size()
    {
        static_assert(std::is_aggregate_v<T>);
        constexpr auto w = while_constexpr<
            break_if<meta_all_transfer_o<
                 meta_object<repeat_raw<T, do_repeat<20, Inits>>, common_object::replace_transform>, 
                 meta_construct_list_maker_decrease_istream<do_repeat<20, Inits>::template to<exp_list>, T>
                 >,
            constructible_cond>
        >{};
        // if constexpr(!w.is_blocked())... 构造失败，因为没被打断
        return exp_size<stream_final_t<typename decltype(w.final_type())::type>> -1;
    }
   
    //试探 is_constructible<T, Inits,...,convert_forbid<T>, Inits...>
    template<size_t N, class T, class Mem_type> struct is_constructible_at
    {
        using constructible_form = repeat_raw<T, do_repeat<size<T>(), Inits>>::template to<selectable_list>;
        using try_constructible = constructible_form::template invoke<N + 1>:://ignored the first arg of std::is_constructible
            template replace_with<convert_forbid<Mem_type>>::
            template to<std::is_constructible>;
        static constexpr bool value = try_constructible::value;
        using type = Mem_type;
    };
   
    template<size_t N, class T, class mem_type_list> struct constructible_at_try
    {};
     //用一个类型列表来试探 is_constructible_at<N, T>
    template<size_t N, class T, template<class...> class mem_type_list, class ...Typs>
    struct constructible_at_try<N, T, mem_type_list<Typs...>>
    {
        struct type_transfer_f
        {
            template<class TL, class T> struct apply_impl { using type = TL; };

            template<size_t N, class T, class MT, class OT> struct apply_impl<is_constructible_at<N, T, MT>, OT>
            {
                using type = is_constructible_at<N, T, OT>;
            };

            template<class this_constl, class Arg> using apply = typename apply_impl<this_constl, Arg>::type;
        };
       //特化元对象， 在循环中构造is_constructible_at, 将试探的类型替换为元输入流输入的类型
        using transfer_constructible_o = meta_object<is_constructible_at<N, T, meta_empty>, type_transfer_f>;

        //由于操作的元对象不一样，不得已又定义了一个打断函数， 当is_constructible_at为真，循环被打断
       //这个条件元函数对象直接继承 is_constructible_at<N, T, OT>
        struct break_if_constructible
        {
            template<class this_mso> struct apply : this_mso::to::type
            {};
        };
        //循环
        using while_type = while_constexpr<
            break_if<
                meta_all_transfer_o<transfer_constructible_o, meta_istream<exp_list<Typs...>>>, break_if_constructible
            >
            >;

        using type = typename decltype(std::declval<while_type>().final_type())::type::to::type;
        //如果这个循环没被打断，即所有类型匹配失败，返回false
        static constexpr bool value = while_type{}.is_blocked();
    };

    using namespace place_holder;

    template<class T> using prepare_types_placeholders = place_holder::placeholder_gen<size<T>()>;
    //生成typelist<_0, _1, _2...>, placeholder_type::value 等于当前所处的位置
    struct not_in_possibilities {};
    //使用apply式的调用，避免手动循环
    template<class T, class TL> struct create_constructible_typelist_impl
    {
        template<class T> struct apply_impl 
        {
            using type = T;
        };
        template<size_t I> struct apply_impl<_<I>>
        {
            using try_type = constructible_at_try<I, T, TL>;
            
            using type = exp_if<try_type::value, typename try_type::type::type, not_in_possibilities>;
        };
        template<class T> using apply = typename apply_impl<T>::type;
    };
    //possibilities<T, TL>::type 返回 T 的成员类型列表，假如匹配成功的话
    template<class T, class Possi> struct possibilities
    {
        using type = exp_fn_apply<create_constructible_typelist_impl<T, Possi>, prepare_types_placeholders<T>>;
    };
   //根据成员列表计算偏移，其实蛋疼了，不TMP也行
    struct append_increase_last_f
    {
        template<class this_tl, class idx_type>
        using apply = meta_invoke<common_object::append, this_tl, Idx<(exp_select<max_index<this_tl>, this_tl> ::value + idx_type::value)>>;
    };

    using offset_start_o = meta_object<exp_list<Idx<0>>, append_increase_last_f>;

    template<class meta_array_typelist>
    using create_offset_array = typename meta_timer_looper_t<
        to_timer<offset_start_o, exp_size<meta_array_typelist>>,
        meta_istream<decrease_transform<meta_array_typelist>>
    >::type;
    //默认内存对齐8
    template<class ...Typs> using offset_array = meta_array<(sizeof(Typs) % 8 ? sizeof(Typs) / 8 * 8 + 8 : sizeof(Typs))...>;
}



using namespace possibility;
int main()
{

    struct X
    {
        int a;
        double b;
        char c;
    };
    X x{ 10, 2.33, 'k' };
    //提供可能构造 X 的类型
    //在编译期瞎猜 X 的构造方式
    using try_list = exp_list<std::string, char, int, double, size_t, long, bool>;
    //得到构造列表后根据类型计算offset
    using offset_ar = possibilities<X, try_list>::type::to<offset_array>;

    using typelist_iter = to_selectable_t<possibilities<X, try_list>::type>;

    using sum_offset = create_offset_array<offset_ar::cv_typelist>;
    //指针+元类型信息走起
    unsigned char* ucptr = reinterpret_cast<unsigned char*>(&x);
    std::cout << "X has members of: " <<
        typeid(typelist_iter::get<0>).name() << "," <<
        typeid(typelist_iter::get<1>).name() << "," <<
        typeid(typelist_iter::get<2>).name() << "," << std::endl;
    std::cout << *(reinterpret_cast<std::add_pointer_t<typelist_iter::get<0>>>(ucptr + meta_to_array<sum_offset>::at<0>::value)) << std::endl;
    std::cout << *(reinterpret_cast<std::add_pointer_t<typelist_iter::get<1>>>(ucptr + meta_to_array<sum_offset>::at<1>::value)) << std::endl;
    std::cout << *(reinterpret_cast<std::add_pointer_t<typelist_iter::get<2>>>(ucptr + meta_to_array<sum_offset>::at<2>::value)) << std::endl;

}

注：
这个方法又很多问题，比如，possibilities猜测会失败，因为没有提供所有可能的类型
没有针对不同的类型计算不同的内存对齐
...

[AzrBrk]

这段代码旨在提供一种思路，可以通过其他方法复现

[Mq-b]

这模板，，，太夸张了

[AzrBrk]

主要是将几个不同的功能糅合在一起了，然后模板上头了计算offset也模板。。。