如何处理离散的非整数集？

Question

我有一个程序需要执行从一组已知值到另一组已知值的编译时可检查映射：

in      out
------------
8       37
10      61
12      92
13 1/4  109
15 1/4  151
etc

如果输入是整数或均匀分布，这将很容易。 我将迭代行，但也希望能够在可读的庄园中进行查找。

我目前的想法（我不喜欢）是定义一个类似的枚举

enum Size
{
   _8,
   _10,
   _12,
   _13_25,
   _15_25,
   // etc
}

，然后将其设置为两次查找。

还有更好的想法吗？

编辑：我主要关心的是限制我尝试查找的内容。 如果代码可能尝试查找无效的内容，我希望某些内容甚至无法编译。

该集合很小，迭代时间几乎完全无关。

我还没有看到任何比枚举能给我带来任何好处的东西，所以现在我就这样做。 OTOH我会继续关注这个问题。

* 注意：我并不担心捕获指针问题以及其他问题，只是简单的代码，例如 for 循环和变量赋值。

---

本质：为了清晰和普遍性，我对上面的内容进行了过度简化。 我实际上有一个表，其中有 3 个非整数、非均匀轴和一个非数字轴。 此时，我不确定我需要在哪些方向中枚举它。

一些链接可以让您了解我正在寻找的内容：

Boost::SI 和我的 D 版本 相同

Answer 1

不能使用哈希映射吗？

Answer 2

如果您的输入分数仅限于某个 2 的幂分母，您可以使用定点数作为键。 对于您的示例情况，使用 1 位 = 0.25（将每个输入乘以 4），如下所示：

IN maps to Key
--         ---   
8          32   
10         40
12         48 
13 1/4     53
15 1/4     61 

KeyMin= 32

然后您可以使用 Key-KeyMin 作为稀疏数组的索引，该数组包含用于无效条目的标志值，例如 -1。 优点是，如果您的密钥发生变化，它可以使您不必重新编码。 缺点是浪费内存。

Answer 3

使用枚举会丢失数值，除非对变量名进行丑陋的解析。 我会这样做：

class Size
{
    public decimal Val{get;set;}
    private Size(decimal val){this.val = val;}
    public static Size _8 = new Size(8.0);   
    //...
    public Dictionary<Size, Size> sizeMap = new Dictionary<Size, Size>
    {
        {_8, _37}, 
        //...
    };
}

Answer 4

听起来你想要使用类似排序二叉树的东西。 查找和迭代都很快，并且树不会关心条目的间距。

如果您的多个轴是独立的，您可以为每个轴创建一个。

Answer 5

枚举的想法并不太糟糕，但我会动态地进行。 您有一个有效字符串的数组/列表。 字符串列表的索引是地图的关键。

// this could be loaded from a file potentially
// notice that the keys have been sorted.
const char* keys[] = { "10", "12", "13 1/4", "15 1/4", "8", 0 };
float values[] = { 61, 92, 109, 151, 37, 0 };
int key_count = 0;
while (keys[key_count]) ++key_count;

bool find(const char* key, float* val) {
   int idx = bsearch(key, keys, sizeof(const char*), key_count, strcmp);
   if (idx < 0) return false;
   *val = values[idx];
   return true;
}

现在，你说过这里有不止一个维度。 这仅仅意味着您需要多个键数组。

Answer 6

以下是有关如何解决该问题的建议。 使用结构体和数组。

typedef struct{
    float input;
    int   output;
}m_lookup;
m_lookup in_out[] = 
{   
    (float) 8   , 37,
    (float)10   , 61,
    (float)12   , 92,
    (float)13.25,109,
    (float)15.25,151,
};

int get_Var(float input)
{
    int i=0;
    for(i=0;i<sizeof(in_out);i++)
        if(in_out[i].input == input)
            return in_out[i].output;
    // Here you could make some special code for your compiler
    return 0;
}
int main(void)
{
    printf("Input 15.25 : Output %d\n",get_Var(15.25));
    printf("Input 13,25 : Output %d\n",get_Var(13.25));
    printf("Illegal input:\n");
    printf("Input 5 : Output %d\n",get_Var(5));
    system( "pause" );
    return 0;
}

如果你能多解释一下实质内容，我可能会做出一些调整。

如果您决定在编译时检查它，那么您可以像这样使用枚举：

enum Size
{
   i_8=37,
   i_10=61,
   i_12=92,
   i_13_25=109,
   i_15_25=151,
   // etc
}