Question

结构

这是我需要构建的主要结构，创建一个类型tParent（伪代码，其中()是一个数组声明）：

type Ne {
    single D()
    dword DC
    single B
    single V
    single D
}

type L {
    Ne Ns()
    dword NC
}

type tParent {
    L La()
    dword LC
    single LR
}

tParent nTest 

// would be accessed like nTest.La(0).Ns(0).B = 42 ...

但是，必须使用的专有语言不包含“用户定义类型的数组”。支持嵌套，因此除了上面类型中的()数组声明外，代码都是有效的。

问题

实现此结构的最有效方法是从算法上讲。我想将子类型扩展为数组，并使用第二个保存偏移的数组访问它们，但我怀疑这在任何方面都是有效的。

Answer 1

我所能建议的是创建字节数组并使用它，就像在汇编语言中使用内存一样。您可以隐藏访问器方法（如

）背后的内存访问复杂性

 single typeName_fieldName_get(byte arr(), int offset) {
      return convertFomByteToSingle(
          arr(offset+OFFSET_OF_FIELD_NAME + 0),
          arr(offset+OFFSET_OF_FIELD_NAME + 1),
          arr(offset+OFFSET_OF_FIELD_NAME + 2),
          ....
          );
 }

Answer 2

似乎应该可以编写一个看起来像

的函数

function("nTest", ["La","Ns"], ["0","0"]).b = 42

它的行为很像嵌套字典，它是字典中的第一个元素。第二个元素是子类列表，第三个元素是子词典的键列表。组合子项及其键的替代形式可以是：

function("nTest", [["La","0"],["Ns","0"]]).b = 42

虽然，避免在数组中使用多个类型的需要需要使用类似下面的内容，但如果嵌套结构没有预定义的高度，则处理起来可能很棘手：

function("nTest","La","0","Ns","0").b = 42

至于功能的内容。它基本上只是这样做（但通过循环或递归）：

temp = nTest
temp = temp.La
temp = temp(0)
temp = temp.Ns
temp = temp(0)
return temp

如果我在解析后没有弄错的话，这很接近于如何将功能添加到语言中。虽然可能需要在放入函数之前将所有内容转换为字符串，然后将其转换回字。

虽然，由于它是严格打字的，你可能必须包含这些类型，结果如下：

function(["tParent","nTest"],["L","La"],["int","0"],["Ne","Ns"],["int","0"],["single","D"]) = 42

Answer 3

由于你不能使用指针，我能想到的唯一解决方案是使用链表。在迭代期间向前移动将是 O（1）但是查找当然将是 O（n），因此根据您的使用情况，它可能不是最有效的解决方案，但它在我看来，它是唯一一个无法在原始数组中存储内存地址以用作指针的可用。

type tParent {
    ListL La
    dword LC
    single LR
}

type ListL {
    NodeL First
}

type NodeL {
    NodeL Next
    L Value
}

如何在不支持它们的语言中有效地实现包含其他嵌套结构数组的嵌套结构？

结构

问题

3 个答案: