通过多个分隔符将字符串拆分为单词

Question

我有一些文本（有意义的文本或算术表达式），我想将其拆分为单词。
如果我有一个分隔符，我会使用：

std::stringstream stringStream(inputString);
std::string word;
while(std::getline(stringStream, word, delimiter)) 
{
    wordVector.push_back(word);
}

如何将字符串分解为带有多个分隔符的标记？

Answer 1

假设其中一个定界符是换行符，则以下内容将读取该行，并用定界符进一步对其进行拆分。 在此示例中，我选择了定界符空间，撇号和分号。

std::stringstream stringStream(inputString);
std::string line;
while(std::getline(stringStream, line)) 
{
    std::size_t prev = 0, pos;
    while ((pos = line.find_first_of(" ';", prev)) != std::string::npos)
    {
        if (pos > prev)
            wordVector.push_back(line.substr(prev, pos-prev));
        prev = pos+1;
    }
    if (prev < line.length())
        wordVector.push_back(line.substr(prev, std::string::npos));
}

Answer 2

如果您有增强能力，可以使用：

#include <boost/algorithm/string.hpp>
std::string inputString("One!Two,Three:Four");
std::string delimiters("|,:");
std::vector<std::string> parts;
boost::split(parts, inputString, boost::is_any_of(delimiters));

Answer 3

我不知道为什么没人指出手动方式，但是这里是：

const std::string delims(";,:. \n\t");
inline bool isDelim(char c) {
    for (int i = 0; i < delims.size(); ++i)
        if (delims[i] == c)
            return true;
    return false;
}

在功能上：

std::stringstream stringStream(inputString);
std::string word; char c;

while (stringStream) {
    word.clear();

    // Read word
    while (!isDelim((c = stringStream.get()))) 
        word.push_back(c);
    if (c != EOF)
        stringStream.unget();

    wordVector.push_back(word);

    // Read delims
    while (isDelim((c = stringStream.get())));
    if (c != EOF)
        stringStream.unget();
}

这样，您可以根据需要对delims做一些有用的事情。

Answer 4

在这里，很久以后，使用 C++20 的解决方案：

constexpr std::string_view words{"Hello-_-C++-_-20-_-!"};
constexpr std::string_view delimeters{"-_-"};
for (const std::string_view word : std::views::split(words, delimeters)) {
    std::cout << std::quoted(word) << ' ';
}
// outputs: Hello C++ 20!

必需的标题：

#include <ranges>
#include <string_view>

参考： https : //en.cppreference.com/w/cpp/ranges/split_view

Answer 5

如果您对如何自己做而不是使用boost感兴趣。

假设定界符字符串可能很长-假设M，检查字符串中的每个字符（如果它是一个定界符），则每个都会花费O（M），因此循环处理原始字符串中的所有字符，说长度N为O（M * N）。

我将使用字典（如映射-“分隔符”到“ booleans”-但在这里，我将使用一个简单的布尔数组，每个分隔符的index = ascii值都为true）。

现在，对字符串进行迭代，并检查char是否是定界符，即为O（1），这最终使我们整体获得O（N）。

这是我的示例代码：

const int dictSize = 256;    

vector<string> tokenizeMyString(const string &s, const string &del)
{
    static bool dict[dictSize] = { false};

    vector<string> res;
    for (int i = 0; i < del.size(); ++i) {      
        dict[del[i]] = true;
    }

    string token("");
    for (auto &i : s) {
        if (dict[i]) {
            if (!token.empty()) {
                res.push_back(token);
                token.clear();
            }           
        }
        else {
            token += i;
        }
    }
    if (!token.empty()) {
        res.push_back(token);
    }
    return res;
}


int main()
{
    string delString = "MyDog:Odie, MyCat:Garfield  MyNumber:1001001";
//the delimiters are " " (space) and "," (comma) 
    vector<string> res = tokenizeMyString(delString, " ,");

    for (auto &i : res) {

        cout << "token: " << i << endl;
    }
return 0;
}

注意：tokenizeMyString按值返回向量，并首先在堆栈上创建它，因此我们在这里使用编译器的功能>>> RVO-返回值优化:)

Answer 6

使用Eric Niebler的range-v3库：

https://godbolt.org/z/ZnxfSa

#include <string>
#include <iostream>
#include "range/v3/all.hpp"

int main()
{
    std::string s = "user1:192.168.0.1|user2:192.168.0.2|user3:192.168.0.3";
    auto words = s  
        | ranges::view::split('|')
        | ranges::view::transform([](auto w){
            return w | ranges::view::split(':');
        });
      ranges::for_each(words, [](auto i){ std::cout << i  << "\n"; });
}

Answer 7

使用std::regex

std::regex可以在几行中进行字符串拆分：

std::regex re("[\\|,:]");
std::sregex_token_iterator first{input.begin(), input.end(), re, -1}, last;//the '-1' is what makes the regex split (-1 := what was not matched)
std::vector<std::string> tokens{first, last};

自己尝试