如何加快大字符串的解析速度?

所以我做了一个可以读取各种配置文件的程序。其中一些配置文件可以很小，有些可以半大(最大的配置文件是 3,844 KB(。

读入文件存储在一个字符串中(在下面的程序中称为 sample(。

然后，我让程序根据各种格式规则从字符串中提取信息。这很好用，唯一的问题是在读取较大的文件时它非常慢......

我想知道我是否可以做些什么来加快解析速度，或者是否有一个现有的库可以满足我的需要(提取字符串直到分隔符并在同一级别的 2 个分隔符之间提取字符串字符串(。任何帮助都会很棒。

这是我的代码和它应该如何工作的示例......

#include "stdafx.h"
#include <string>
#include <vector>
std::string ExtractStringUntilDelimiter(
std::string& original_string,
const std::string& delimiter,
const int delimiters_to_skip = 1)
{
std::string needle = "";
if (original_string.find(delimiter) != std::string::npos)
{
int total_found = 0;
auto occurance_index = static_cast<size_t>(-1);
while (total_found != delimiters_to_skip)
{
occurance_index = original_string.find(delimiter);
if (occurance_index != std::string::npos)
{
needle = original_string.substr(0, occurance_index);
total_found++;
}
else
{
break;
}
}
// Remove the found string from the original string...
original_string.erase(0, occurance_index + 1);
}
else
{
needle = original_string;
original_string.clear();
}
if (!needle.empty() && needle[0] == '"')
{
needle = needle.substr(1);
}
if (!needle.empty() && needle[needle.length() - 1] == '"')
{
needle.pop_back();
}
return needle;
}
void ExtractInitialDelimiter(
std::string& original_string,
const char delimiter)
{
// Remove extra new line characters
while (!original_string.empty() && original_string[0] == delimiter)
{
original_string.erase(0, 1);
}
}
void ExtractInitialAndFinalDelimiters(
std::string& original_string,
const char delimiter)
{
ExtractInitialDelimiter(original_string, delimiter);
while (!original_string.empty() && original_string[original_string.size() - 1] == delimiter)
{
original_string.erase(original_string.size() - 1, 1);
}
}
std::string ExtractStringBetweenDelimiters(
std::string& original_string,
const std::string& opening_delimiter,
const std::string& closing_delimiter)
{
const size_t first_delimiter = original_string.find(opening_delimiter);
if (first_delimiter != std::string::npos)
{
int total_open = 1;
const size_t opening_index = first_delimiter + opening_delimiter.size();
for (size_t i = opening_index; i < original_string.size(); i++)
{
// Check if we have room for opening_delimiter...
if (i + opening_delimiter.size() <= original_string.size())
{
for (size_t j = 0; j < opening_delimiter.size(); j++)
{
if (original_string[i + j] != opening_delimiter[j])
{
break;
}
else if (j == opening_delimiter.size() - 1)
{
total_open++;
}
}
}

// Check if we have room for closing_delimiter...
if (i + closing_delimiter.size() <= original_string.size())
{
for (size_t j = 0; j < closing_delimiter.size(); j++)
{
if (original_string[i + j] != closing_delimiter[j])
{
break;
}
else if (j == closing_delimiter.size() - 1)
{
total_open--;
}
}
}

if (total_open == 0)
{
// Extract result, and return it...
std::string needle = original_string.substr(opening_index, i - opening_index);
original_string.erase(first_delimiter, i + closing_delimiter.size());
// Remove new line symbols
ExtractInitialAndFinalDelimiters(needle, 'n');
ExtractInitialAndFinalDelimiters(original_string, 'n');
return needle;
}
}
}
return "";
}
int main()
{
std::string sample = "{n"
"Line1n"
"Line2n"
"{n"
"SubLine1n"
"SubLine2n"
"}n"
"}";
std::string result = ExtractStringBetweenDelimiters(sample, "{", "}");
std::string LineOne = ExtractStringUntilDelimiter(result, "n");
std::string LineTwo = ExtractStringUntilDelimiter(result, "n");
std::string SerializedVector = ExtractStringBetweenDelimiters(result, "{", "}");
std::string SubLineOne = ExtractStringUntilDelimiter(SerializedVector, "n");
std::string SubLineTwo = ExtractStringUntilDelimiter(SerializedVector, "n");
// Just for testing...
printf("LineOne: %sn", LineOne.c_str());
printf("LineTwo: %sn", LineTwo.c_str());
printf("tSubLineOne: %sn", SubLineOne.c_str());
printf("tSubLineTwo: %sn", SubLineTwo.c_str());
system("pause");
}