使用字符串分隔符在C++中解析（分割）一个字符串（标准C++）。

我正在用C++语言解析一个字符串，方法如下。

string parsed,input="text to be parsed";
stringstream input_stringstream(input);

if(getline(input_stringstream,parsed,' '))
{
     // do some processing.
}

用单字符定界符进行解析是可以的。但如果我想用一个字符串作为分隔符，该怎么办。

例如。我想分割。

scott>=tiger

用>=作为分隔符，这样我就可以得到scott和tiger。

Lightness Races with Monica
已编辑的问题 24日 五月 2018 в 9:59
编程
c++ parsing split
10日 一月 2013 в 7:16
38 种观点
对该问题的评论 (6)
解决办法

你可以使用[std::string::find()][1]函数找到你的字符串分隔符的位置，然后使用[std::string::substr()][2]来获得一个标记。

例子。

std::string s = "scott>=tiger";
std::string delimiter = ">=";
std::string token = s.substr(0, s.find(delimiter)); // token is "scott"

  • find(const string& str, size_t pos = 0)函数返回str在字符串中第一次出现的位置，如果没有找到该字符串，则返回[npos][3]。

  • substr(size_t pos = 0, size_t n = npos)函数返回对象的子串，从pos位置开始，长度为npos。

如果你有多个定界符，在你提取了一个标记后，你可以删除它（包括定界符）以继续进行后续的提取（如果你想保留原始字符串，只需使用s = s.substr(pos + delimiter.length());）。

s.erase(0, s.find(delimiter) + delimiter.length());

这样，你就可以很容易地循环获得每个标记。

完整示例 


std::string s = "scott>=tiger>=mushroom";
std::string delimiter = ">=";

size_t pos = 0;
std::string token;
while ((pos = s.find(delimiter)) != std::string::npos) {
    token = s.substr(0, pos);
    std::cout
评论(5)

本方法使用std::string::find，通过记住前一个子串标记的开头和结尾，不对原始字符串进行突变。


#include 
#include 

int main()
{
    std::string s = "scott>=tiger";
    std::string delim = ">=";

    auto start = 0U;
    auto end = s.find(delim);
    while (end != std::string::npos)
    {
        std::cout
评论(0)

你可以使用下一个函数来分割字符串。

vector split(const string& str, const string& delim)
{
    vector tokens;
    size_t prev = 0, pos = 0;
    do
    {
        pos = str.find(delim, prev);
        if (pos == string::npos) pos = str.length();
        string token = str.substr(prev, pos-prev);
        if (!token.empty()) tokens.push_back(token);
        prev = pos + delim.length();
    }
    while (pos < str.length() && prev < str.length());
    return tokens;
}
评论(2)

用于字符串定界符

根据字符串定界符来拆分字符串。 如根据字符串定界符"-+"拆分字符串"-+"，输出将是{"adsf", "qwret", "nvfkbdsj", "orthdfjgh", "dfjrleih"}。 


#include 
#include 
#include 

using namespace std;

// for string delimiter
vector split (string s, string delimiter) {
    size_t pos_start = 0, pos_end, delim_len = delimiter.length();
    string token;
    vector res;

    while ((pos_end = s.find (delimiter, pos_start)) != string::npos) {
        token = s.substr (pos_start, pos_end - pos_start);
        pos_start = pos_end + delim_len;
        res.push_back (token);
    }

    res.push_back (s.substr (pos_start));
    return res;
}

int main() {
    string str = "adsf-+qwret-+nvfkbdsj-+orthdfjgh-+dfjrleih";
    string delimiter = "-+";
    vector v = split (str, delimiter);

    for (auto i : v) cout
Arafat Hasan
编辑本段答案9日 十月 2018 в 10:32
评论(5)

strtok允许你传递多个字符作为分隔符。我敢打赌，如果你输入">="，你的例子字符串会被正确分割（尽管>和=被算作单独的分隔符）。

编辑：如果你不想使用c_str()将字符串转换为char*，你可以使用substr和find_first_of来进行标记。

string token, mystring("scott>=tiger");
while(token != mystring){
  token = mystring.substr(0,mystring.find_first_of(">="));
  mystring = mystring.substr(mystring.find_first_of(">=") + 1);
  printf("%s ",token.c_str());
}
ryanbwork
编辑本段答案10日 一月 2013 в 7:49
评论(4)

这段代码从文本中拆分出一行，并将所有人加到一个向量中。

vector split(char *phrase, string delimiter){
    vector list;
    string s = string(phrase);
    size_t pos = 0;
    string token;
    while ((pos = s.find(delimiter)) != string::npos) {
        token = s.substr(0, pos);
        list.push_back(token);
        s.erase(0, pos + delimiter.length());
    }
    list.push_back(s);
    return list;
}

召集人：

vector listFilesMax = split(buffer, "\n");
fret
编辑本段答案14日 十一月 2018 в 5:23
评论(4)

这里'是我对这个问题的看法。 它处理了边缘情况，并接受了一个可选的参数来从结果中删除空条目。

bool endsWith(const std::string& s, const std::string& suffix)
{
    return s.size() >= suffix.size() &&
           s.substr(s.size() - suffix.size()) == suffix;
}

std::vector split(const std::string& s, const std::string& delimiter, const bool& removeEmptyEntries = false)
{
    std::vector tokens;

    for (size_t start = 0, end; start < s.length(); start = end + delimiter.length())
    {
         size_t position = s.find(delimiter, start);
         end = position != string::npos ? position : s.length();

         std::string token = s.substr(start, end - start);
         if (!removeEmptyEntries || !token.empty())
         {
             tokens.push_back(token);
         }
    }

    if (!removeEmptyEntries &&
        (s.empty() || endsWith(s, delimiter)))
    {
        tokens.push_back("");
    }

    return tokens;
}

例子

split("a-b-c", "-"); // [3]("a","b","c")

split("a--c", "-"); // [3]("a","","c")

split("-b-", "-"); // [3]("","b","")

split("--c--", "-"); // [5]("","","c","","")

split("--c--", "-", true); // [1]("c")

split("a", "-"); // [1]("a")

split("", "-"); // [1]("")

split("", "-", true); // [0]()
Beder Acosta Borges
编辑本段答案25日 五月 2017 в 9:15
评论(0)

我将使用boost::tokenizer。 这里的文档解释了如何制作一个合适的标记器函数：http://www.boost.org/doc/libs/1_52_0/libs/tokenizer/tokenizerfunction.htm

这里有一个适合你情况的函数。


struct my_tokenizer_func
{
    template
    bool operator()(It& next, It end, std::string & tok)
    {
        if (next == end)
            return false;
        char const * del = ">=";
        auto pos = std::search(next, end, del, del + 2);
        tok.assign(next, pos);
        next = pos;
        if (next != end)
            std::advance(next, 2);
        return true;
    }

    void reset() {}
};

int main()
{
    std::string to_be_parsed = "1) one>=2) two>=3) three>=4) four";
    for (auto i : boost::tokenizer(to_be_parsed))
        std::cout
评论(2)

这是一个完整的方法，可以在任何定界符上分割字符串，并返回一个被分割的字符串的向量。

它是根据 ryanbwork 的答案改编的。 然而，他的检查是 if(token != mystring)如果你的字符串中有重复的元素，会得到错误的结果。 这是我解决这个问题的方法。

vector Split(string mystring, string delimiter)
{
    vector subStringList;
    string token;
    while (true)
    {
        size_t findfirst = mystring.find_first_of(delimiter);
        if (findfirst == string::npos) //find_first_of returns npos if it couldn't find the delimiter anymore
        {
            subStringList.push_back(mystring); //push back the final piece of mystring
            return subStringList;
        }
        token = mystring.substr(0, mystring.find_first_of(delimiter));
        mystring = mystring.substr(mystring.find_first_of(delimiter) + 1);
        subStringList.push_back(token);
    }
    return subStringList;
}
评论(0)

答案已经有了，但是选择答案使用的是擦除功能，这非常昂贵，想一想一些非常大的字符串（以MB为单位）。 因此我使用了下面的函数。

vector split(const string& i_str, const string& i_delim)
{
    vector result;

    size_t found = i_str.find(i_delim);
    size_t startIndex = 0;

    while(found != string::npos)
    {
        string temp(i_str.begin()+startIndex, i_str.begin()+found);
        result.push_back(temp);
        startIndex = found + i_delim.size();
        found = i_str.find(i_delim, startIndex);
    }
    if(startIndex != i_str.size())
        result.push_back(string(i_str.begin()+startIndex, i_str.end()));
    return result;      
}
评论(0)

如果您不想修改字符串（就像 Vincenzo Pii 的答案一样），并且**想把最后一个 token 也输出，您可能想使用这种方法。


inline std::vector splitString( const std::string &s, const std::string &delimiter ){
    std::vector ret;
    size_t start = 0;
    size_t end = 0;
    size_t len = 0;
    std::string token;
    do{ end = s.find(delimiter,start); 
        len = end - start;
        token = s.substr(start, len);
        ret.emplace_back( token );
        start += len + delimiter.length();
        std::cout
评论(0)

#include
#include
using namespace std;

int split_count(string str,char delimit){
return count(str.begin(),str.end(),delimit);
}

void split(string str,char delimit,string res[]){
int a=0,i=0;
while(a
评论(1)

这对于字符串（或单字符）定界符应该是完美的，不要忘记包含#include <sstream>。 不要忘记包含#include <sstream>。


std::string input = "Alfa=,+Bravo=,+Charlie=,+Delta";
std::string delimiter = "=,+"; 
std::istringstream ss(input);
std::string token;
std::string::iterator it;

while(std::getline(ss, token, *(it = delimiter.begin()))) {
    while(*(++it)) ss.get();
    std::cout
评论(0)
std::vector split(const std::string& s, char c) {
  std::vector v;
  unsigned int ii = 0;
  unsigned int j = s.find(c);
  while (j < s.length()) {
    v.push_back(s.substr(i, j - i));
    i = ++j;
    j = s.find(c, j);
    if (j >= s.length()) {
      v.push_back(s.substr(i, s,length()));
      break;
    }
  }
  return v;
}
评论(1)