как создать сложный тип с использованием кортежей и вариативных шаблонов

Question

На первом месте я не очень опытный программист в C++ 11 и шаблоны, я читал много сообщений, но не могу понять, как писать моя идея (если это возможно), говоря, что это моя идея.

Моя идея создать сложный тип компилятор времени, я пытаюсь следовать этим правилам

• Определяется как структуры, я имею в виду поле, поле (без синтаксиса restrinctions), например, что-то вроде this ,
• Каждый тип поля будет одним из следующих типов: int, short, long, byte, bool и std :: string.
• И вот сложная часть, я хочу кортеж, где каждая позиция будет ссылкой на каждое поле, таким образом я могу получить доступ к сохраненным полям данных по полю или получить кортеж к нему. У меня нет проблем с использованием std :: tuples или boost :: tuples.

Каждое предложение, например, совет и любые другие комментарии приветствуются, я пытаюсь научиться этому.

Заранее спасибо

С наилучшими пожеланиями

Edit: я могу дать вам код, где я пытался сделать это, возможно, не лучший aprouch, так что я открыт для предложений.

#include <iostream> 
#include <tuple> 

/* Trait Def */ 
template<typename T> 
struct field_trait 
{ 
    typedef T type; 
    typedef type &ref; 
    typedef type *pointer; 
    typedef const type &const_ref; 
}; 

/* Field Def */ 
template <typename T> 
struct Field : field_trait<Field<T>> 
{ 
    typedef typename T::type value_type; 
    typedef typename Field<T>::type field_type; 

    typename T::type storage; 

    typename T::ref &operator[](const T &c) 
    { 
     return storage; 
    }; 
}; 


/* Linear inheritance def */ 
template<class...Ts> 
struct operator_index_inherit {}; 

template<class T0, class T1, class...Ts> 
struct operator_index_inherit<T0, T1, Ts...> : T0, operator_index_inherit<T1, Ts...> 
{ 
    using T0::operator[]; 
    using operator_index_inherit<T1, Ts...>::operator[]; 
}; 

template<class T0> 
struct operator_index_inherit<T0>: T0 
{ 
    using T0::operator[]; 
}; 

template<class... Fields> 
struct bind : operator_index_inherit<Field<Fields>...> 
{ 
    using base = operator_index_inherit<Field<Fields>...>; 
    using base::operator[]; 

    bind() : data(make_tuple(int(0),string(""))) 
    {}; 
    typedef std::tuple<typename Field<Fields>::value_type&... > tuple_t; 
    tuple_t data; 
}; 

/* Data type def */ 
struct t_age : field_trait<int>{}; 
struct t_name : field_trait<std::string>{}; 

typedef Field<t_age> age; 

int main() 
{ 
    bind<t_age,t_name> data; 

    data[t_age()] = 123; 
    data[t_name()] = "pepe"; 

    return 0; 
} 

Этот код не компилируется, ошибка вызвана объявлением типа «tuple_t» и «данные» tuple_t

С уважением

Answer 1

Принимая догадку на то, что вы ищете , у меня есть быстрый, грубый пример:

#include <iostream> 

#include <string> 
#include <tuple> 

class Type 
{ 
public: 
    Type() : t{std::tie(a, b, c, d, e, f)} {} 

    int a; 
    short b; 
    long c; 
    unsigned char d; 
    bool e; 
    std::string f; 

    std::tuple<int&, short&, long&, unsigned char&, bool&, std::string&> t; 
}; 

int main() 
{ 
    Type A{}; 

    A.c = 5; 

    std::cout << std::get<2>(A.t) << std::endl; 

    return 0; 
} 

с demo.