C 字典/地图

Question

我想映射结构成员，这样我就可以消除循环中的 if 分支。在 C 中实现此功能的最佳方法或约定是什么？我想它可能是一个二维数组......然后我可以将整数映射到 char 键？

    char chunk[32];
    int n;
    int i;
    char *ptr = config;
    while (*ptr != '\0') {
        int items_read = sscanf(ptr, "%31[^;]%n", chunk, &n);

        if(chunk[0] == 'S' && chunk[1] == 'P') {
            for(i=0;i<GLOBAL_MEAS_CUTOFF; i++) {
                theMeas[i].signal_path = atoi(&chunk[2]);
            }
        }    
        if(chunk[0] == 'T' && chunk[1] == 'L') {
            for(i=0;i<GLOBAL_MEAS_CUTOFF; i++) {
                theMeas[i].trace_length = atoi(&chunk[2]);
            }
        }    
        if(chunk[0] == 'S' && chunk[1] == 'R') {
            for(i=0;i<GLOBAL_MEAS_CUTOFF; i++) {
                theMeas[i].sample_rate = atoi(&chunk[2]);
            }
        }   

        chunk[0]='\0';
        if (items_read == 1)
            ptr += n;
        if ( *ptr != ';' ) {
            break;
        }
        ++ptr;
    }

Answer 1

我怀疑你（理想情况下）想要的是一本字典：

theMeas[i]["signal_path"] = atoi(&chunk[2]);

当然，上述语法在 C 中永远不会发生，但这在这里并不重要。问题是您必须编写实现字典数据类型的所有代码，我怀疑这有点过分了。

所以我怀疑你（真正）想要的是一种可以在循环中使用名称的方法：

foreach(signal_path, trace_length, sample_rate)

我在这里告诉你你可以做到这一点！最简单的方法是使用 enum：

enum fields {
  signal_path,
  trace_length,
  sample_rate,
  END_fields,
  UNKNOWN_fields,
  BEGIN_fields = 0,
};

使用数组代替 struct 成员：

int theMeas[size][END_fields];

要索引“成员”，请使用：

theMeas[i][signal_path];

您可以循环遍历所有“成员” ，”你可以使用这个：

for(enum fields j = BEGIN_fields; j != END_fields; j++)
    theMeas[i][j];

当你想要进行基于字符的比较时，这确实会有点崩溃，但我们可以做一点：

const char *to_str(enum fields f)
{
#define FIELD(x) case x: return #x
    switch(f)
      {
        FIELD(signal_path);
        FIELD(trace_length);
        FIELD(sample_rate);
        default: return "<unknown>";
      }
#undef FIELD
}

enum fields from_str(const char *c)
{
#define FIELD(x) if(!strcmp(c, #x)) return x
        FIELD(signal_path);
        FIELD(trace_length);
        FIELD(sample_rate);
        default: return UNKNOWN_fields;
#undef FIELD
}

enum fields from_abv(char *c)
{
    for(enum fields i = BEGIN_fields; i < END_fields; i++)
      {
        char *field = field_str(i);
        if(tolower(c[0]) == field[0] && tolower(c[1]) == strchr(field, '_')[1])
            return i;
      }
    return UNKNOWN_fields;
}

你的 if 语句可以替换为：

theMeas[i][from_abv(chunk)] = atoi(&chunk[2]);

或者，更安全:

enum fields j = from_abv(chunk);
if(j != UNKNOWN_fields) theMeas[i][j] = atoi(&chunk[2]);
else /* erroneous user input */;

这是我所能得到的最接近的了。

请注意，我特意使用了命名方案来促进宏的创建，这些宏将自动完成大部分工作。让我们试试：

#define member(name, ...) \
  enum name { __VA_ARGS__, \
              M_END_##name, \
              M_UNKNOWN_##name, \
              M_BEGIN_##name = 0 }

#define miter(name, var) \
        enum name var = M_BEGIN_##name; var != M_END_##name; var++

#define msize(name) M_END_##name

用法：

// define our fields
member(fields, signal_path, trace_length, sample_rate);

// declare object with fields
int theMeas[N][msize(fields)];

for(size_t i = 0; i < N; i++)
    // iterate over fields
    for(miter(fields, j))
        // match against fields
        if(j == from_abv(chunk))
            theMeas[i][j] = atoi(&chunk[2]);

最后一点看起来还不错。它仍然允许您通过 theMeas[i][signal_path] 进行类似于 struct 的访问，但允许您迭代“成员”，并隐藏大部分宏背后的繁重工作。

to_str 和 from_str 函数需要更多的宏技巧才能实现自动化。您可能需要研究一下 P99。对于一般情况，我不推荐使用 from_abv 函数，因为我们无法保证下次创建可迭代字段时将使用带下划线的名称。 （当然，您可以删除 from_abv 函数并为您的成员提供难以理解的名称，例如 SP、TL 和 SR，允许您直接将它们与字符串数据进行比较，但您需要将 strcmp 更改为 memcmp，其大小参数为 (sizeof( #x) - 1)。然后，您拥有 from_abv 的所有位置都只需使用 from_str，它会自动为您生成。）

但是， from_abv 并不难定义，老实说，您可以直接将上面的 if 块复制并粘贴到其中 - 它会稍微更有效，但如果您添加一个“成员”，你必须更新该函数（如所写，如果你添加一个成员，它会自行更新。）

Answer 2

C 支持指向函数的指针，因此您可以创建一个数组指向函数的指针并根据您的输入对数组进行寻址。这将要求您使用相同的签名实现其他功能。

另一种方法可能是将 if 子句封装在单独的函数中并使用参数调用它。

然而，我认为无论哪种方式，你都不会获得太多的加速（如果有的话）。

Answer 3

您可以使用指向整数的指针重写您的逻辑，如下所示：

while (*ptr != '\0') {
    int items_read = sscanf(ptr, "%31[^;]%n", chunk, &n);

    int *p = NULL;
    if(chunk[0] == 'S' && chunk[1] == 'P') {
        p = &theMeas[i].signal_path;
    }    
    if(chunk[0] == 'T' && chunk[1] == 'L') {
        p = &theMeas[i].trace_length;
    }    
    if(chunk[0] == 'S' && chunk[1] == 'R') {
        p = &theMeas[i].sample_rate;
    }

    for(i=0;i<GLOBAL_MEAS_CUTOFF; i++) {
        *p = atoi(&chunk[2]);
    }   

这种方法将有关要更改哪个变量（if 语句）的决定与实际执行常见工作的代码分开。每种情况（for 循环）。

您当然需要检查 p == NULL 是否为 chunk[0] 和 chunk[1] 与您的任何内容不匹配正在期待。

Answer 4

不幸的是，对于简单的 C99，这是不可能的，因为数组索引只能是无符号整数。但可能 strncmp() 函数更适合您？

#define EQUALN(a,b,n) (strncmp(a, b, n) == 0)

...

if(EQUALN(chunk, "SP", 2)) {
    for(i=0;i<GLOBAL_MEAS_CUTOFF; i++) {
        theMeas[i].signal_path = atoi(&chunk[2]);
    }
}    
else if(EQUALN(chunk, "TL", 2)) {
    for(i=0;i<GLOBAL_MEAS_CUTOFF; i++) {
        theMeas[i].trace_length = atoi(&chunk[2]);
    }
}    
else if(EQUALN(chunk, "SR", 2)) {
    for(i=0;i<GLOBAL_MEAS_CUTOFF; i++) {
        theMeas[i].sample_rate = atoi(&chunk[2]);
    }
}

Answer 5

如果（这是一个相当大的如果）您可以依赖数据始终是这三个选项之一，那么我们可以在这三种情况下构造一个“最小完美哈希”。假设字符集是 ASCII（或与 ASCII 一致）：

L = 76, 0 mod 4
P = 80, 0 mod 4
R = 82, 2 mod 4
S = 83, 3 mod 4
T = 84, 0 mod 4

因此，S+P 是 3 mod 4，T+L 是 0 mod 4，S+R 是 1 mod 4。不是最小的，但足够接近：

size_t lookup[3] = {
    offsetof(Mea, trace_length),
    offsetof(Mea, sample_rate),
    0,
    offsetof(Mea, signal_path)
};

size_t offset = lookup[((unsigned)chunk[0] + chunk[1]) % 4];

for(i=0;i<GLOBAL_MEAS_CUTOFF; i++) {
    int *fieldptr = (int*)(((char*)(theMeas+i)) + offset);
    *fieldptr = atoi(&chunk[2]);
}

您可能更喜欢使用宏或内联函数给这只猪涂上口红，或者用 char *fieldptr 代替 int *fieldptr，从 ((char*)theMeas 开始) + offset，并每次将其增加 sizeof(Mea)。

如果您不能依赖友好的数据，那么您至少需要某种类型的分支（条件或通过函数指针的调用），以避免在数据错误的情况下编写任何内容。即使将其保持为 1，您也可能需要 3 个案例的 64k 条目查找表，这有点稀疏，因此您可能最好使用条件语句。