C++；substr，优化速度 所以几天前我就开始学习C++。我正在编写一个简单的xHTML解析器，它不包含嵌套标记。对于测试，我使用了以下数据：（大约10k字符）我只需要解析p、h2和h3标记之间的数据。我的目标是将标记及其内容解析为以下结构： struct Node { short tag; // p = 1, h2 = 2, h3 = 3 std::string data; };

例如，

asdasd

将被解析为

tag=1，string=“asdasd”

。我不想使用第三方LIB，我正在尝试速度优化

这是我的密码：

short tagDetect(char * ptr){
    if (*ptr == '/') {
        return 0;
    }

    if (*ptr == 'p') {
        return 1;
    }

    if (*(ptr + 1) == '2')
        return 2;

    if (*(ptr + 1) == '3')
        return 3;

    return -1;
}


struct Node {
    short tag;
    std::string data;

    Node(std::string input, short tagId) {
        tag = tagId;
        data = input;
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    std::string input = GetData(); // returns the pastebin content above
    std::vector<Node> elems;

    String::size_type pos = 0;
    char pattern = '<';

    int openPos;
    short tagID, lastTag;

    double  duration;
    clock_t start = clock();

    for (int i = 0; i < 20000; i++) {
        elems.clear();

        pos = 0;
        while ((pos = input.find(pattern, pos)) != std::string::npos) {
            pos++;
            tagID = tagDetect(&input[pos]);
            switch (tagID) {
            case 0:
                if (tagID = tagDetect(&input[pos + 1]) == lastTag && pos - openPos > 10) {
                    elems.push_back(Node(input.substr(openPos + (lastTag > 1 ? 3 : 2), pos - openPos - (lastTag > 1 ? 3 : 2) - 1), lastTag));
                }

                break;
            case 1:
            case 2:
            case 3:
                openPos = pos;
                lastTag = tagID;
                break;
            }
        }

    }

    duration = (double)(clock() - start) / CLOCKS_PER_SEC;
    printf("%2.1f seconds\n", duration);
}

短标记检测（char*ptr）{
如果（*ptr=='/'））{
返回0；
}
如果（*ptr=='p'）{
返回1；
}
如果（*（ptr+1）='2'）
返回2；
如果（*（ptr+1）='3'）
返回3；
返回-1；
}
结构节点{
短标签；
std：：字符串数据；
节点（标准：：字符串输入，短标记ID）{
tag=tagId；
数据=输入；
}
};
int _tmain（int argc，_TCHAR*argv[]
{
std:：string input=GetData（）；//返回上面的pastebin内容
std：：向量元素；
字符串：：size\u type pos=0；
char pattern='有比线性搜索更好的子字符串算法，即O（MxN）。查找Boyer-Moore和Knuth-Morris-Platt算法。我几年前测试过，B-M赢了

你也可以考虑使用正则表达式，它比你的线性搜索更昂贵，但在实际搜索中可能更有效。
 < P>而不是存储子串，可以存储引用原始字符串中的部分的数据（通过指针、迭代器或整数索引）。。您只需小心，只要使用引用数据，原始字符串就会保持不变。即使您不愿意直接使用它，也要从中得到提示。
考虑到他要查找的字符串是3个已知字符，进行简单搜索可能会更快。@MooingDuck可能不是。我期待着您的基准测试我想得越多，我就越觉得你可能是对的（多变量的糟糕测试）问题是，我需要将数据导出到
NodeJS
，这样只要我的解析器完成了，我就需要发送数据。Deepsy，按照他所说的存储引用，然后对最后找到的元素执行一次单次传递，以执行段的实际字符串副本。只要这样，你就会明白
substr
为什么要花费这么多时间我猜它是在构造一个要返回的新字符串，这意味着调用
new
，这代价很高。然后它在构造一个
节点
实例，然后它在执行
push_back
，这也可以进行更多的内存重新分配，除非您先保留足够大的内存。如果您看到了这一点，请找出如何重新分配o内存不足。请尝试将
节点
构造函数更改为：
节点（const std:：string&input，短tagId）：标记（tagId），数据（input）{}
@rici，更改构造函数使我的代码速度提高了约1/3！谢谢！您还有其他建议吗？我将非常感谢。