[C++]将一个字符串切成字符串，由另一个字符串中给出的符号以外的任何内容分隔

[C++]Cut up a string into strings separated by anything other than symbols given in another string?

本文关键字：字符串 另一个 符号 分隔 任何内 C++ 一个      更新时间：2023-10-16

编辑：这不是重复的！给出的链接中的问题有所不同。我没有用空格分隔，而是用给定字符串中的字符以外的任何内容分隔。因此，另一个线程中的答案不起作用。

EDIT2：请注意，我没有分隔符，我需要用除notOf以外的任何东西分隔。

在我的程序中，这意味着将名为 word 的字符串切割成名为 words 的向量中的字符串，这些向量由 notOf 以外的任何内容组成并分隔。所以notOf有点像getline中的分隔物。

例如，"&otherwise[taken=(and)-redacted-"应该变成"otherwise"、"taken"、"and"和"redacted"。

我

试过写作，想出了你在下面看到的东西，但它不起作用，而且，我被告知，相当丑陋。用你的判断来判断它是否值得修复或重新编写。

#include <string>
#include <sstream>
#include <vector>
#include <iostream>
using namespace std;
int main()
{
    string notOf = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM0123456789$'"";
    string word = "&otherwise[taken=(and)-redacted-";
    stringstream in(word);
    vector<string> words;
    if (word.find_first_not_of(notOf) == string::npos)
        words.push_back(word);
    else while (word.find_first_not_of(notOf) != string::npos)
    {
        int index = word.find_first_not_of(notOf);
        string tok;
        getline(in, tok, word[index]);
        if (index != 0)
            words.push_back(tok);
        word = word.substr(index);
    }
    for (vector<string>::iterator it = words.begin(); it != words.end(); ++it)
        cout << *it << endl;
    system("pause");
    return 0;
}

你可以试试这个：

vector<string>split(string str,string Separator)
{
    vector<string>answer;
    string temp;
    int len=str.size();
    for(int i=0;i<len;i++)
    {
        bool isSeparator=false;
        for(int j=0;j<Separator.length();j++)
        {
            if(str[i]==Separator[j]) 
              isSeparator=true;
        }
        if(!isSeparator) 
        {
            temp+=str[i];
            continue;
        }
        if(temp!="") 
          answer.push_back(temp);
        temp=""; 
    }
    if(temp!="") 
      answer.push_back(temp);
    return answer;
}

您只需要在字符串Separator指定分隔符即可。此函数将返回分隔的字符串。在这里，分离将发生在其中一个Separator发现的地方。

编辑：

如果要对notOf进行分区（即notOf以外的），可以执行以下操作：

vector<string>split(string str,string Separator)
{
    vector<string>answer;string temp;
    int len=str.size();
    for(int i=0;i<len;i++)
    {
        bool isSeparator=true;
        for(int j=0;j<Separator.length();j++)
        {
            if(str[i]==Separator[j])
              isSeparator=false;
        }
        if(!isSeparator)
        {
            temp+=str[i];
            continue;
        }
        if(temp!="")
          answer.push_back(temp);
        temp="";
    }
    if(temp!="")
      answer.push_back(temp);
    return answer;
}
int main()
{
    string notOf = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM0123456789$'"";
    string word = "&otherwise[taken=(and)-redacted-";
    vector<string>v=split(word,notOf);
    for(int i=0;i<v.size();i++)
      cout<<v[i]<<"n";
return 0;
}

希望对:)有所帮助

我正在考虑最优雅的方法，如果您被赋予一系列分隔符或有效字符，并且只使用标准库。

以下是我的想法：

通过一系列分隔符将单词拆分为字符串向量：

template<class Container>
std::vector<std::string> split_by_delimiters(const std::string& input, const Container& delimiters)
{
    std::vector<std::string> result;
    for (auto current = begin(input) ; current != end(input) ; )
    {
        auto first = find_if(current, end(input), not_in(delimiters));
        if (first == end(input)) break;
        auto last = find_if(first, end(input), is_in(delimiters));
        result.emplace_back(first, last);
        current = last;
    }
    return result;
}

要以另一种方式拆分，请通过提供一系列有效字符：

template<class Container>
std::vector<std::string> split_by_valid_chars(const std::string& input, const Container& valid_chars)
{
    std::vector<std::string> result;
    for (auto current = begin(input) ; current != end(input) ; )
    {
        auto first = find_if(current, end(input), is_in(valid_chars));
        if (first == end(input)) break;
        auto last = find_if(first, end(input), not_in(valid_chars));
        result.emplace_back(first, last);
        current = last;
    }
    return result;
}

is_in和not_in的定义如下：

namespace detail {
    template<class Container>
    struct is_in {
        is_in(const Container& charset)
        : _charset(charset)
        {}
        bool operator()(char c) const
        {
            return find(begin(_charset), end(_charset), c) != end(_charset);
        }
        const Container& _charset;
    };
    template<class Container>
    struct not_in {
        not_in(const Container& charset)
        : _charset(charset)
        {}
        bool operator()(char c) const
        {
            return find(begin(_charset), end(_charset), c) == end(_charset);
        }
        const Container& _charset;
    };
}
template<class Container>
detail::not_in<Container> not_in(const Container& c)
{
    return detail::not_in<Container>(c);
}
template<class Container>
detail::is_in<Container> is_in(const Container& c)
{
    return detail::is_in<Container>(c);
}
相关文章：