c++ 不使用任何库拆分字符数组

Question

我一直遇到这个奇怪的问题，当我printf中的 printf output 时split代码正确返回，但在将其作为实例调用时会错误地返回 output。

问题：将其作为实例调用时如何获得正确的输出？（请参阅下面的用法）

这是代码：

typedef struct SplitText
{
    int splitLen;
    char* splitTxt[100];
    char* subTxt(char* text, int index, int len)
    {
        char subTxt_[1000];
        int count = 0;
        for (int i = 0; i < 1000; i++)
            subTxt_[i] = '\0';
        for (int i = index; i < index + len; i++)
            subTxt_[count++] = text[i];

        return subTxt_;
    }

    void split(char* text, char sep)
    {
        char separator[3] = { '<', sep, '>' };
        int textLen = strlen(text);
        int splitIndex = 0;
        int splitCount = 0;
        for (int t = 0; t < textLen; t++)
        {
            if (text[t] == separator[0] && text[t + 1] == separator[1] && text[t + 2] == separator[2])
            {
                if (splitIndex != 0)
                    splitIndex += 3;
                splitTxt[splitCount] = subTxt(text, splitIndex, t - splitIndex);
                splitIndex = t;
                
                //correct output
                printf(splitTxt[splitCount]);
                printf("\n");

                splitCount++;
            }
        }
        splitLen = splitCount;
    }
}SplitText;

用法：

SplitText st;
st.split("testing<=>split<=>function<=>", '=');
for (int i = 0; i < st.splitLen; i++)
{
    //incorrect output
    printf(st.splitTxt[i]);
    printf("\n");
}
printf("--------\n");

Answer 1

这个：

    char* subTxt(char* text, int index, int len)
    {
        char subTxt_[1000];

        ...

        return subTxt_;
    }

是未定义的行为。 返回指向本地堆栈变量（或本地数组 var）的指针将导致发生这种奇怪的事情。

破坏返回指针内容的典型情况是，当调用另一个 function 时，subTxt_ 占用的subTxt_将被下一个调用的 function 的堆栈变量覆盖。

更好的：

    char* subTxt(char* text, int index, int len)
    {
        char *subTxt = new char[1000];

        ...

        return subTxt_;
    }

然后确保调用subTxt的人记得delete [] 。

或者只使用std::string并完成它（除非这是一个学术练习）。

此外，这是未定义的行为：

    for (int t = 0; t < textLen; t++)
    {
        if (text[t] == separator[0] && text[t + 1] == separator[1] && text[t + 2] == separator[2])

当t == textLen-1时，引用text[t+2]和text[t+1]是越界访问。 将其更改为：

    for (int t = 2; t < textLen; t++)
    {
        if (text[t-2] == separator[0] && text[t -1] == separator[1] && text[t] == separator[2])

并在块内对t进行类似的修正。

Answer 2

那么你可以创建一个 splitstring function 而不是结构/类。

无论如何，您的代码看起来仍然很像“C”，它的固定大小字符为 arrays。这将限制可用性和稳定性（越界数组错误）。

C++ 中的字符串通常是 std::string 类型。 然后 C++ 有 string_view 可以对该字符串进行查看（因此不会复制任何数据，但这也意味着您的 string_view 仅在它正在查看的字符串存在期间有效）。

如果您事先不知道字符串中子字符串的数量，则不应使用固定大小的数组，而应使用 std::vector （如果需要可以在内部调整大小）

这就是 split_string function 在当前 C++ 中的样子，请注意，与显示更多您正在做的事情的“C”风格编程相比，该代码还更好地显示了它正在做什么。

std::vector<std::string_view> split_string(std::string_view string, std::string_view delimiters)
{
    std::vector<std::string_view> substrings;
    if(delimiters.size() == 0ul)
    {
        substrings.emplace_back(string);
        return substrings;
    }

    auto start_pos = string.find_first_not_of(delimiters);
    auto end_pos = start_pos;
    auto max_length = string.length();

    while(start_pos < max_length)
    {
        end_pos = std::min(max_length, string.find_first_of(delimiters, start_pos));

        if(end_pos != start_pos)
        {
            substrings.emplace_back(&string[start_pos], end_pos - start_pos);
            start_pos = string.find_first_not_of(delimiters, end_pos);
        }
    }

    return substrings;
}

Answer 3

看看std::string_view 。 您可以避免分配 memory，它有一个内置的 substring function。使用 printf 打印到控制台时要小心，因为“%s”将打印整个字符串。 请参阅 printf 文档。

for(auto view : container_with_string_views)
   printf("%.*s, (int)view.size(), view.data());