如何将 string_view 拆分为多个 string_view 对象而不进行任何动态分配

Question

下面的代码片段来自这个答案。

#include <string>
#include <vector>

void tokenize(std::string str, std::vector<string> &token_v){
    size_t start = str.find_first_not_of(DELIMITER), end=start;

    while (start != std::string::npos){
        // Find next occurence of delimiter
        end = str.find(DELIMITER, start);
        // Push back the token found into vector
        token_v.push_back(str.substr(start, end-start));
        // Skip all occurences of the delimiter to find new start
        start = str.find_first_not_of(DELIMITER, end);
    }
}

现在对于这样的缓冲区：

std::array<char, 150> buffer;

我想要一个 sting_view （指向缓冲区）并将其传递给 tokenizer 函数，并且令牌应该以 std:: 的形式返回string_view 通过输出参数（而不是向量）进行处理，并且它将返回提取的标记数量。界面如下所示：

size_t tokenize( const std::string_view inputStr,
                 const std::span< std::string_view > foundTokens_OUT,
                 const size_t expectedTokenCount )
{
    // implementation
}

int main( )
{
    std::array<char, 150> buffer { " @a hgs -- " };
    const std::string_view sv { buffer.data( ), buffer.size( ) };
    const size_t expectedTokenCount { 4 };

    std::array< std::string_view, expectedTokenCount > foundTokens; // the span for storing found tokens

    const size_t num_of_found_tokens { tokenize( sv, foundTokens, expectedTokenCount ) };

    if ( num_of_found_tokens == expectedTokenCount )
    {
        // do something
        std::clog << "success\n" << num_of_found_tokens << '\n';
    }

    for ( size_t idx { }; idx < num_of_found_tokens; ++idx )
    {
        std::cout << std::quoted( foundTokens[ idx ] ) << '\n';
    }
}

如果有人可以实现类似的 tokenize 函数，但对于基于空格和制表符进行分割的 string_view ，我将不胜感激。我尝试自己写一个，但它没有按预期工作（不支持选项卡）。另外，如果 inputStr 中找到的令牌数量超过 expectedTokenCount，我希望此函数停止工作并返回 expectedTokenCount + 1。这显然效率更高。

这是我的虚拟版本：

size_t tokenize( const std::string_view inputStr,
                 const std::span< std::string_view > foundTokens_OUT,
                 const size_t expectedTokenCount )
{
    if ( inputStr.empty( ) )
    {
        return 0;
    }

    size_t start { inputStr.find_first_not_of( ' ' ) };
    size_t end { start };

    size_t foundTokensCount { };

    while ( start != std::string_view::npos && foundTokensCount < expectedTokenCount )
    {
        end = inputStr.find( ' ', start );
        foundTokens_OUT[ foundTokensCount++ ] = inputStr.substr( start, end - start );
        start = inputStr.find_first_not_of( ' ', end );
    }

    return foundTokensCount;
}

注意：范围库还没有适当的支持（至少在 GCC 上），所以我试图避免这种情况。

Answer 1

我尝试自己写一个，但它没有按预期工作（没有
支持选项卡）。

如果您想支持使用空格和制表符进行拆分，则可以使用 find_first_not_of 的另一个重载：

size_type find_first_not_of(const CharT* s, size_type pos = 0) const;

它将查找第一个字符不等于 s。

因此，您的实现只需将 find_first_not_of(' ') 和 find(' ') 更改为 find_first_not_of(" \t") 和 find_first_of(" \t").

演示

Answer 2

这是我的实现（我之前写过），它可以处理诸如以一个或多个分隔符开头、有重复分隔符并以一个或多个分隔符结尾的输入之类的事情：

它对所有内容都使用 string_views，因此没有内存分配，但要小心不要过早丢弃输入字符串。 string_views 毕竟是非拥有的。

在线演示：https://onlinegdb.com/tytGlOVnk

#include <vector>
#include <string_view>
#include <iostream>

auto tokenize(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;
}

int main()
{
    std::string_view test{ "The, quick! and brown fox. Jumped : over the lazy dog, or did he?" };

    auto tokens = tokenize(test, " ,!.?:");

    for (const auto token : tokens)
    {
        std::cout << token << "\n";
    }

    return 0;
}