C++11 如何使用元组和可变模板创建复杂类型

首先，我在C++11和模板方面不是一个非常熟练的程序员，我读了很多帖子，但我不知道如何写我的想法（如果可能的话），我说，这是我的想法

我的想法是创建一个复杂的编译器时间类型，我试图遵循这个规则

• 像结构一样定义，我指的是一个字段一个字段（没有语法限制），例如
• 每个字段类型都是以下类型之一：int、short、long、byte、bool和std:：string
• 这里是一个棘手的部分，我想要一个元组，其中每个位置都是对每个字段的引用，这样我就可以逐个字段访问存储的数据字段，或者得到一个元组。我可以使用std:：tuples或boost:：tuples

每一个建议，例如，建议和任何其他评论都是受欢迎的，我正在努力学习如何做到这一点

提前谢谢

致意

编辑：我可以给你我试图这样做的代码，也许不是最好的方法，所以我愿意接受建议

#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;
}

#包括
#包括
/*特征定义*/
模板
结构域特征
{
T型；
typedef type&ref；
typedef type*指针；
类型定义常数类型和常数参考；
};
/*场定义*/
模板
结构字段：字段\特征
{
typedef typename T:：type value_type；
typedef typename字段：：type字段\ u type；
类型名T：：类型存储；
类型名T：：引用和运算符[]（常量T&c）
{
返回存储；
};
};
/*线性继承定义*/
模板
结构运算符_索引_继承{}；
模板
结构运算符索引继承：T0，运算符索引继承
{
使用T0:：运算符[]；
使用运算符_索引_继承：：运算符[]；
};
模板
结构运算符\u索引\u继承：T0
{
使用T0:：运算符[]；
};
模板
结构绑定：运算符\u索引\u继承
{
使用base=operator\u index\u inherit；
使用base:：operator[]；
bind（）：数据（生成元组（int（0），字符串（“”））
{};
typedef std:：tuple tuple\t；
元组数据；
};
/*数据类型定义*/
结构t_年龄：字段{}；
结构t_name:field_trait{}；
田间年龄；
int main（）
{
绑定数据；
数据[t_age（）]=123；
数据[t_name（）]=“pepe”；
返回0；
}

此代码未编译，错误是由类型“tuple\u t”和“tuple\u t data”的声明引起的

---

关于

猜猜你在找什么，我有一个简单的例子：

#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;
}

#包括
#包括
#包括
类类型
{
公众：
Type（）：t{std:：tie（a，b，c，d，e，f）}{}
INTA；
短b；
长c；
无符号字符d；
布尔e；
std：：字符串f；
std：：元组t；
};
int main（）
{
A型{}；
A.c=5；
我不知道你在问什么。你能提供一个这样的东西的示例用法吗？我必须同意巴里的观点：不清楚你在问什么。也许提供一个（甚至是非工作的）最简单的示例会让事情更容易理解。嗨，R2，你的示例很清晰，功能齐全，但在我的例子中，我不能使用它，因为我需要声明很多此类的类，所以有很多工作要做。