问如何在C++11中构建具有在编译时递增值的整数成员的结构序列

EN

template <typename ...Ts>
void f(Ts... args)
{
    const int dummy[] = {0, ((std::cout << std::hex << args << std::endl), 0)...};
    static_cast<void>(dummy); // Avoid warning for unused variable
}

template <std::size_t N, typename Tuple, std::size_t ...Is>
void process(std::array<std::uint8_t, N> const& array, Tuple tuple, std::index_sequence<Is...>)
{
    int i = 0;
    const int dummy[] = {((memcpy(&std::get<Is>(tuple), array.data() + i, sizeof(std::tuple_element_t<Is, Tuple>)), i += sizeof(std::tuple_element_t<Is, Tuple>)), 0)...};
    static_cast<void>(dummy); // Avoid warning for unused variable
    f(std::get<Is>(tuple)...);
}

template <std::size_t N, typename ... Ts>
void process(std::array<std::uint8_t, N> const& array, std::tuple<Ts...> tuple)
{
    process(array, tuple, std::index_sequence_for<Ts...>{});
}

#include <array>
#include <tuple>
#include <iostream>

template <typename ... Ts>
class process
 {
   private:

      template <typename T>
      static T getVal (std::uint8_t const * a)
       {
         T ret { *a++ };

         for ( auto i = 1U ; i < sizeof(T) ; ++i )
          {
            ret <<= 8;
            ret  += *a++;
          }

         return ret;
       }

      static std::size_t postIncr (std::size_t & pos, std::size_t add)
       {
         std::size_t ret { pos };

         pos += add;

         return ret;
       }

   public: 
      template <std::size_t N>
      static std::tuple<Ts...> func (std::array<std::uint8_t, N> const & a)
       {
         std::size_t  pos { 0U };

         return { getVal<Ts>(a.data()+postIncr(pos, sizeof(Ts)))... };
       }
 };

int main ()
 { 
   std::array<std::uint8_t, 7U>
      bytes{{0x01U, 0x02U, 0x03U, 0x04U, 0x10U, 0x20U, 0x30U}};

   auto tpl
    { process<std::uint32_t, std::uint8_t, std::uint16_t>::func(bytes) };

   std::cout << "- 0x" << std::hex << std::get<0>(tpl) << std::endl;
   std::cout << "- 0x" << int(std::get<1>(tpl)) << std::endl;
   std::cout << "- 0x" << std::get<2>(tpl) << std::endl;
 }

#include <iostream>
#include <type_traits>
#include <cstring>
#include <typeinfo>

using namespace std;

template <size_t O,size_t I,size_t C,typename...>
struct byte_offset_impl;

template <size_t O,size_t I,size_t C,typename T,typename... Ts>
struct byte_offset_impl< O, I, C,T,Ts...> : 
    std::conditional<I == C,
      std::integral_constant<size_t,O>,
      byte_offset_impl<O + sizeof(T),I,C+1,Ts...>    
    >::type
{};


template <typename T>
struct type_c 
{ using type = T; };

template <size_t I,size_t C,typename...>
struct type_at_impl;

template <size_t I,size_t C,typename T,typename... Ts>
struct type_at_impl<I, C,T,Ts...> : 
    std::conditional<I == C,
      type_c<T>,
      type_at_impl<I,C+1,Ts...>  
    >::type
{};


template <size_t I,typename... Ts>
constexpr size_t byte_offset = byte_offset_impl<0,I,0,Ts...>::value;

template <size_t I,typename... Ts>
using type_at = typename type_at_impl<I,0,Ts...>::type;

template <typename...Ts>
struct generic_class
{
    generic_class(char* byteptr) : byteptr_(byteptr)
    {};


    template <size_t I>
    auto get() -> type_at<I, Ts...>& // needed for c++11
    {
        using result_type = type_at<I, Ts...>;
        return *reinterpret_cast<result_type*>(&byteptr_[byte_offset<I, Ts...>]);

    }

    template <size_t I>
    auto get_v() -> type_at<I, Ts...> // needed for c++11
    {
        using result_type = type_at<I, Ts...>;
        result_type result;

        std::memcpy(&result, &byteptr_[byte_offset<I, Ts...>], sizeof(result_type));

        return result;
    }
    char* byteptr_;
};


int main() {

    char bytes[sizeof(uint32_t) + sizeof(uint8_t) + sizeof(uint16_t)];

    uint32_t u32 = 1561;
    uint8_t u8 = 22;
    uint16_t u16 = 99;

    char* bytesp = bytes;
    std::memcpy(bytesp, &u32, sizeof(uint32_t)); bytesp += sizeof(uint32_t);
    std::memcpy(bytesp, &u8, sizeof(uint8_t)); bytesp += sizeof(uint8_t);
    std::memcpy(bytesp, &u16, sizeof(uint16_t));

    generic_class<uint32_t, uint8_t, uint16_t> gen(bytes);
    std::cout << (uint32_t)gen.get<0>() << std::endl;
    std::cout << (uint32_t)gen.get<1>() << std::endl;
    std::cout << (uint32_t)gen.get<2>() << std::endl;

    std::cout << (uint32_t)gen.get_v<0>() << std::endl;
    std::cout << (uint32_t)gen.get_v<1>() << std::endl;
    std::cout << (uint32_t)gen.get_v<2>() << std::endl;
}