Question

在我的C ++ / QT应用程序中，我有一个包含数百个变量的结构，如下所示：

struct MyStruct
{
    int a1;
    double a2;
    struct InnerStruct
    {
        int b1;
        bool b2;
        struct InnerInnerStruct
        {
            char c1;
              .
              .
              .
        };
        InnerInnerStruct b3;
          .
          .
          .

    };
    InnerStruct a3;
      .
      .
      .
};

我希望有一个每个struct成员变量地址的映射，它有整数作为键类型，所以我可以通过它的键访问它：

MyStruct ms;
theMap[0] = &(ms.a1);
theMap[1] = &(ms.a2);
theMap[2] = &(ms.a3.b1);
theMap[3] = &(ms.a3.b2);
theMap[4] = &(ms.a3.b3.c1);

theMap[3] = true; // MyStruct::InnerStruct::b2 is 'true' now

我该如何定义Map对象？我需要什么样的神秘主义才能拥有这个功能？普通模板？提升东西？一些胶印技巧？ QVariant不知何故？

注意：不幸的是，Qt的属性系统不是一个选项。

编辑：关于我的请求的奇怪性质：我从某个地方接收数据帧，比如设备。数据的前4个字节指定帧的类型。所以每当我收到这些数据时，我都必须将它放入Device struct的相应成员变量中。由于有数百种不同的数据类型，因为我需要使用这种匹配不止一个地方，我想摆脱苦差事 - 或者至少做一次 - （＆＃34; if / else＆＃34;和＆＃34;切换＆＃34;语句。

Answer 1

更新：查看我的other answer您的问题。将每个数据帧放入树数据模型中的自己的元素中会更加清晰。这种元素的子元素将是框架中的数据成员。这与具有不同数量元素的各种帧的情况相匹配。如果每个帧具有相同数量的元素，那么表模型将更适合。 Qt的模型 - 视图系统对所有数据使用QVariants，并提供索引到任意复杂模型的方法，所以为什么要重新发明轮子。

在内部，您仍然可以使用结构来保存数据，但至少您不需要具有固定的全局（外部）结构。在创建原型模型时，可以为每个顶级元素（例如，最顶层的行）分配其数据类型，在内部创建基础数据结构等。

现在回到原来的方法。

类似QVariant的方法可行，如果整数键是运行时属性，那就是实际使其工作的唯一方法。如果你希望整数键只在编译时有用，那么当然整数规范的模板化函数/仿函数/类成员就可以了。

现在该值已分配给变体，“变体”必须将分配转发给目标成员。

theMap可以是您想要的任何容器类型。功能在“变体”中。我们称之为Handle，因为它本质上是变量的句柄。

您可以编写支持转换的代码，例如让双句柄允许分配整数可能很有用。

让我再说一遍：这是一些真正邪恶的设计，我认为不需要任何破碎的东西。这是一个反模式。它尖叫：有人搞砸了。不要这样做。

以下是最简单的实现。

#include <QMap>
#include <QVariant>

class Handle
{
    QVariant::Type type;
    void * address;
public:
    Handle() : type(QVariant::Invalid), address(0) {}
    explicit Handle(int* p) : type(QVariant::Int), address(p) {}
    explicit Handle(bool * p) : type(QVariant::Bool), address(p) {}
    explicit Handle(double* p) : type(QVariant::Double), address(p) {}
    Handle & operator=(int* p) { return *this = Handle(p); }
    Handle & operator=(int v) {
        if (type == QVariant::Int) { *(int*)address = v; }
        else if (type == QVariant::Double) { *(double*)address = v; }
        else Q_ASSERT(type == QVariant::Invalid);
        return *this;
    }
    int toInt() const { Q_ASSERT(type == QVariant::Int); return *(int*)address; }
    Handle & operator=(bool* b) { return *this = Handle(b); }
    Handle & operator=(bool b) {
        Q_ASSERT(type == QVariant::Bool); *(bool*)address = b;
        return *this;
    }
    bool toBool() const { Q_ASSERT(type == QVariant::Bool); return *(bool*)address; }
    Handle & operator=(double* p) { return *this = Handle(p); }
    Handle & operator=(double d) {
        Q_ASSERT(type == QVariant::Double); *(double*)address = d;
        return *this;
    }
    int toDouble() const { Q_ASSERT(type == QVariant::Double); return *(double*)address; }
};

struct MyStruct
{
    int a1;
    double a2;
    struct InnerStruct
    {
        int b1;
        bool b2;
    } b3;
};

int main()
{
    MyStruct s;
    QMap<int, Handle> map;
    map[0] = &s.a1;
    map[1] = &s.a2;
    map[2] = &s.b3.b1;
    map[3] = &s.b3.b2;
    map[0] = 10;
    map[1] = 1.0;
    map[2] = 20;
    map[3] = true;
    return 0;
}

将成员变量映射到迭代

1 个答案: