Question

我需要在某些C代码中查找字符串标识符，并考虑如何编写查询代码。标识符和字符串在编译时是固定的，不太可能改变。我认为字符串数组的索引最有效 - 即lookup1。

有时在代码中，标识符不是从0开始，或者编号中存在间隙，因此为这些情况选择了lookup2。 lookup2使用switch语句。

另一个选项是lookup3，它使用带有整数到字符串映射的结构。

我想到了一些优点和缺点。

如果标识符不是从零开始或存在间隙

，则

lookup2更灵活

如果标识符从零开始并且没有间隙，那么lookup1会更好吗？如果没有，那么去查找2方法？

lookup3怎么样？

这是遗留代码，定义已经存在。对于新代码，枚举会更好吗？

一般来说，类别中会有5-20个定义。可能超过100个。

这是代码。

#include <stdio.h>

#define RINGING     0x0
#define DIALING     0x1
#define IDLE        0x2
#define ENGAGED     0x3
#define CONNECTED   0x4

static const char* const lookup1(int id) {
    static const char* const identifiers[] = {
        "RINGING",
        "DIALING",
        "IDLE",
        "ENGAGED",
        "CONNECTED" };

    int size = sizeof(identifiers) / sizeof(identifiers[0]);
    if (id >= 0 && id < size) {
        return identifiers[id];
    }
    return "Unknown identifier";
}


static const char* const lookup2(int id) {
    switch (id) {
    case RINGING: return "RINGING";
    case DIALING: return "DIALING";
    case IDLE: return "IDLE";
    case ENGAGED: return "ENGAGED";
    case CONNECTED: return "CONNECTED";
    default: return "unknown";
    }
}

static const char* const lookup3(int id) {
    struct id2name {
        int id;
        const char* const name;
    };

    static struct id2name pairings[] = {
        { RINGING, "RINGING" },
        { DIALING, "DIALING" },
        { IDLE, "IDLE" },
        { ENGAGED, "ENGAGED" },
        { CONNECTED, "CONNECTED" } };

    int size = sizeof(pairings) / sizeof(pairings[0]);
    if (id >= 0 && id < size) {
        return pairings[id].name;
    }

    return "Unknown identifier";
}


int main() {
    const int identifiers[] = { RINGING, DIALING, IDLE, ENGAGED, CONNECTED };
    const int size = sizeof(identifiers) / sizeof(identifiers[0]);
    for (int i = 0; i < size; ++i) {
        printf("using lookup1 id %d is: %s\n", i, lookup1(i));
        printf("using lookup2 id %d is: %s\n", i, lookup2(i));
        printf("using lookup3 id %d is: %s\n", i, lookup3(i));
    }
}

Answer 1

为了清晰，简洁和速度，很难击败诸如lookup1()之类的表查找。然而，这并不是说其他方法可能至少在速度上无法竞争。对于相对性能问题，您确实需要进行基准测试。

如果最大索引号很大或任何索引号小于零，或者你不能依赖至少C99，那么基于直接阵列的表查找是有问题的，但是否则，索引之间存在差距不是特别的问题，包括在数组的开始和使用的最低索引之间。考虑一下：

#define INITIALIZER(x) [x] = #x,

const char *lookup4(int x) {
    static const char * const table[] = {
        INITIALIZER(RINGING)
        INITIALIZER(DIALING)
        INITIALIZER(IDLE)
        INITIALIZER(ENGAGED)
        INITIALIZER(CONNECTED)
        // initializers have the form:
        // [MACRO] = "MACRO",
    };

    const char *result = ((x < 0 | x >= (sizeof(table) / sizeof(table[0]))) 
        ? NULL 
        : table[x];

    return result ? result : "unknown";
}

使用指定的初始值设定项（由INITIALIZER()宏生成）来初始化查找表中与有效字符串对应的那些元素;其他人将是NULL。这最终与您的lookup1()非常相似。

您的lookup2()没有什么特别的错误。它干净清晰，我想大多数编译器都会为它生成非常有效的代码。

然而，当lookup3()出现时，我认为没有理由比任何其他人更喜欢它。您不使用消息编号，那么为什么要将它们存储在结构中？但是，如果没有它们，你就不会需要一个结构，所以你基本上有一个更复杂的lookup1()实现。如果您确实使用了数字 - 例如通过在阵列中搜索所请求的消息号 - 然后平均比其他方法更昂贵。

Answer 2

如果标识符从零开始且没有间隙，那么lookup1会更好吗？

是

如果没有则转到lookup2方法？

是

lookup3怎么样？

lookup3是错误的。您需要迭代所有配对并检查ID，即：

static struct id2name pairings[] = {
    { RINGING, "RINGING" },
    { DIALING, "DIALING" },
    { IDLE, "IDLE" },
    { ENGAGED, "ENGAGED" },
    { CONNECTED, "CONNECTED" } };

int size = sizeof(pairings) / sizeof(pairings[0]);
for (i = 0; i < size; i++) {
    if (pairings[i].id == id) {
        return pairings[i].name;
    }
}

如果配对[]中的ID被排序，您可以更快地打破for循环，即

for (i = 0; i < size && pairings[i].id < id; i++) {

对于新代码，枚举会更好吗？

不是在性能方面，但它们看起来更好。

对于简单的整数到字符串查找，哪种查找方法最有效

2 个答案: