blocks|key|401807|text|strtok允许您将多个字符作为分隔符进行传递。我敢打赌，如果传入">=“，您的示例字符串将被正确拆分(即使>和=被算作单独的分隔符)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|401808|编辑如果您不想使用c_str()将字符串转换为字符*，您可以使用substr和find_first_of进行标记化。|style|CODE|401809|string+token,+mystring("scott>=tiger");
while(token+!=+mystring){
++token+=+mystring.substr(0,mystring.find_first_of(">="));
++mystring+=+mystring.substr(mystring.find_first_of(">=")+%2B+1);
++printf("%25s+",token.c_str());
}|code-block|syntax|javascript|401810|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cplusplus.com/reference/cstring/strtok/|1|http://www.cplusplus.com/reference/string/string/substr/|2|http://www.cplusplus.com/reference/string/string/find_first_of/^0|0|6|0|0|9|7|W|6|1|13|D|2|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@$A|13|B|14|F|G]]|9|@$A|15|B|16|1|17]|$A|18|B|19|1|1A]]|C|$]]|$1|H|3|I|5|J|7|1B|8|@]|9|@]|C|$K|L]]|$1|M|3|-4|5|6|7|1C|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]|W|$5|P|Q|R|C|$S|X]]]]

<a href="http://www.cplusplus.com/reference/cstring/strtok/" rel="noreferrer">strtok</a> allows you to pass in multiple chars as delimiters. I bet if you passed in ">=" your example string would be split correctly (even though the > and = are counted as individual delimiters).

EDIT if you don't want to use <code>c_str()</code> to convert from string to char*, you can use <a href="http://www.cplusplus.com/reference/string/string/substr/" rel="noreferrer">substr</a> and <a href="http://www.cplusplus.com/reference/string/string/find_first_of/" rel="noreferrer">find_first_of</a> to tokenize.

<pre><code>string token, mystring("scott&gt;=tiger");
while(token != mystring){
 token = mystring.substr(0,mystring.find_first_of("&gt;="));
 mystring = mystring.substr(mystring.find_first_of("&gt;=") + 1);
 printf("%s ",token.c_str());
}
</code></pre>

blocks|key|401923|text|我会使用boost::tokenizer。下面的文档解释了如何创建适当的记号赋予器函数：http://www.boost.org/doc/libs/1_52_0/libs/tokenizer/tokenizerfunction.htm|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|401924|这里有一个适用于你的案例。|401925|struct+my_tokenizer_func
{
++++template<typename+It>
++++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+%2B+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<my_tokenizer_func>(to_be_parsed))
++++++++std::cout+<<+i+<<+'\n';
}|code-block|syntax|javascript|401926|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_52_0/libs/tokenizer/tokenizerfunction.htm^0|4|G|18|21|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|11|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

I would use <code>boost::tokenizer</code>. Here's documentation explaining how to make an appropriate tokenizer function: <a href="http://www.boost.org/doc/libs/1_52_0/libs/tokenizer/tokenizerfunction.htm" rel="noreferrer">http://www.boost.org/doc/libs/1_52_0/libs/tokenizer/tokenizerfunction.htm</a>

Here's one that works for your case.

<pre><code>struct my_tokenizer_func
{
 template&lt;typename It&gt;
 bool operator()(It&amp; next, It end, std::string &amp; tok)
 {
 if (next == end)
 return false;
 char const * del = "&gt;=";
 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&gt;=2) two&gt;=3) three&gt;=4) four";
 for (auto i : boost::tokenizer&lt;my_tokenizer_func&gt;(to_be_parsed))
 std::cout &lt;&lt; i &lt;&lt; '\n';
}
</code></pre>

blocks|key|401986|text|此方法使用std::string::find，而不会通过记住前一个子字符串标记的开头和结尾而改变原始字符串。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|401987|#include+<iostream>
#include+<string>

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+<<+s.substr(start,+end+-+start)+<<+std::endl;
++++++++start+=+end+%2B+delim.length();
++++++++end+=+s.find(delim,+start);
++++}

++++std::cout+<<+s.substr(start,+end);
}|code-block|syntax|javascript|401988|entityMap^0|5|H|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

This method uses <code>std::string::find</code> without mutating the original string by remembering the beginning and end of the previous substring token.

<pre><code>#include &lt;iostream&gt;
#include &lt;string&gt;

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

 auto start = 0U;
 auto end = s.find(delim);
 while (end != std::string::npos)
 {
 std::cout &lt;&lt; s.substr(start, end - start) &lt;&lt; std::endl;
 start = end + delim.length();
 end = s.find(delim, start);
 }

 std::cout &lt;&lt; s.substr(start, end);
}
</code></pre>

blocks|key|183958|text|您可以使用next函数拆分字符串：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|183959|vector<string>+split(const+string&+str,+const+string&+delim)
{
++++vector<string>+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+%2B+delim.length();
++++}
++++while+(pos+<+str.length()+&&+prev+<+str.length());
++++return+tokens;
}|code-block|syntax|javascript|183960|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can use next function to split string:

<pre><code>vector&lt;string&gt; split(const string&amp; str, const string&amp; delim)
{
 vector&lt;string&gt; 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 &lt; str.length() &amp;&amp; prev &lt; str.length());
 return tokens;
}
</code></pre>

blocks|key|183962|text|std::vector<std::string>+split(const+std::string&+s,+char+c)+{
++std::vector<std::string>+v;
++unsigned+int+ii+=+0;
++unsigned+int+j+=+s.find(c);
++while+(j+<+s.length())+{
++++v.push_back(s.substr(i,+j+-+i));
++++i+=+%2B%2Bj;
++++j+=+s.find(c,+j);
++++if+(j+>=+s.length())+{
++++++v.push_back(s.substr(i,+s,length()));
++++++break;
++++}
++}
++return+v;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|183963|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>std::vector&lt;std::string&gt; split(const std::string&amp; s, char c) {
 std::vector&lt;std::string&gt; v;
 unsigned int ii = 0;
 unsigned int j = s.find(c);
 while (j &lt; s.length()) {
 v.push_back(s.substr(i, j - i));
 i = ++j;
 j = s.find(c, j);
 if (j &gt;= s.length()) {
 v.push_back(s.substr(i, s,length()));
 break;
 }
 }
 return v;
}
</code></pre>

blocks|key|184015|text|这是我对此的看法。它处理边缘情况，并接受一个可选参数来从结果中删除空条目。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|184016|bool+endsWith(const+std::string&+s,+const+std::string&+suffix)
{
++++return+s.size()+>=+suffix.size()+&&
+++++++++++s.substr(s.size()+-+suffix.size())+==+suffix;
}

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

++++for+(size_t+start+=+0,+end;+start+<+s.length();+start+=+end+%2B+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+%7C%7C+!token.empty())
+++++++++{
+++++++++++++tokens.push_back(token);
+++++++++}
++++}

++++if+(!removeEmptyEntries+&&
++++++++(s.empty()+%7C%7C+endsWith(s,+delimiter)))
++++{
++++++++tokens.push_back("");
++++}

++++return+tokens;
}|code-block|syntax|javascript|184017|示例|184018|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]()|184019|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here's my take on this. It handles the edge cases and takes an optional parameter to remove empty entries from the results.

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

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

 for (size_t start = 0, end; start &lt; 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 &amp;&amp;
 (s.empty() || endsWith(s, delimiter)))
 {
 tokens.push_back("");
 }

 return tokens;
}
</code></pre>

Examples

<pre><code>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]()
</code></pre>

blocks|key|184061|text|这段代码将行从文本中拆分出来，并将每个人添加到一个向量中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|184062|vector<string>+split(char+*phrase,+string+delimiter){
++++vector<string>+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+%2B+delimiter.length());
++++}
++++list.push_back(s);
++++return+list;
}|code-block|syntax|javascript|184063|调用者：|184064|vector<string>+listFilesMax+=+split(buffer,+"\n");|184065|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This code splits lines from text, and add everyone into a vector.

<pre><code>vector&lt;string&gt; split(char *phrase, string delimiter){
 vector&lt;string&gt; 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;
}
</code></pre>

Called by: 

<pre><code>vector&lt;string&gt; listFilesMax = split(buffer, "\n");
</code></pre>

blocks|key|184097|text|#include<iostream>
#include<algorithm>
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<str.size()){
res[i]=str.substr(a,str.find(delimit));
a%2B=res[i].size()%2B1;
i%2B%2B;
}
}

int+main(){

string+a="abc.xyz.mno.def";
int+x=split_count(a,'.')%2B1;
string+res[x];
split(a,'.',res);

for(int+i=0;i<x;i%2B%2B)
cout<<res[i]<<endl;
++return+0;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|184098|P.S:仅当拆分后字符串的长度相等时才有效|unstyled|184099|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>#include&lt;iostream&gt;
#include&lt;algorithm&gt;
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&lt;str.size()){
res[i]=str.substr(a,str.find(delimit));
a+=res[i].size()+1;
i++;
}
}

int main(){

string a="abc.xyz.mno.def";
int x=split_count(a,'.')+1;
string res[x];
split(a,'.',res);

for(int i=0;i&lt;x;i++)
cout&lt;&lt;res[i]&lt;&lt;endl;
 return 0;
}
</code></pre>

P.S: Works only if the lengths of the strings after splitting are equal

blocks|key|402194|text|这是一个完整的方法，它在任何分隔符上拆分字符串，并返回被分割的字符串的向量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|402195|这是对来自ryanbwork的答案的改编。但是，如果字符串中有重复的元素，他对：if(token+!=+mystring)的检查会给出错误的结果。这就是我对这个问题的解决方案。|offset|length|style|CODE|402196|vector<string>+Split(string+mystring,+string+delimiter)
{
++++vector<string>+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)+%2B+1);
++++++++subStringList.push_back(token);
++++}
++++return+subStringList;
}|code-block|syntax|javascript|402197|entityMap^0|0|14|L|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

This is a complete method that splits the string on any delimiter and returns a vector of the chopped up strings. 

It is an adaptation from the answer from ryanbwork. However, his check for: <code>if(token != mystring)</code> gives wrong results if you have repeating elements in your string. This is my solution to that problem.

<pre><code>vector&lt;string&gt; Split(string mystring, string delimiter)
{
 vector&lt;string&gt; 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;
}
</code></pre>

blocks|key|402227|text|答案已经存在了，但selected-answer使用的是erase函数，这是非常昂贵的，想想一些非常大的字符串(以MB为单位)。因此，我使用下面的函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|402228|vector<string>+split(const+string&+i_str,+const+string&+i_delim)
{
++++vector<string>+result;
++++
++++size_t+found+=+i_str.find(i_delim);
++++size_t+startIndex+=+0;

++++while(found+!=+string::npos)
++++{
++++++++result.push_back(string(i_str.begin()%2BstartIndex,+i_str.begin()%2Bfound));
++++++++startIndex+=+found+%2B+i_delim.size();
++++++++found+=+i_str.find(i_delim,+startIndex);
++++}
++++if(startIndex+!=+i_str.size())
++++++++result.push_back(string(i_str.begin()%2BstartIndex,+i_str.end()));
++++return+result;++++++
}|code-block|syntax|javascript|402229|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Answer is already there, but selected-answer uses erase function which is very costly, think of some very big string(in MBs). Therefore I use below function.
<pre><code>vector&lt;string&gt; split(const string&amp; i_str, const string&amp; i_delim)
{
 vector&lt;string&gt; result;
 
 size_t found = i_str.find(i_delim);
 size_t startIndex = 0;

 while(found != string::npos)
 {
 result.push_back(string(i_str.begin()+startIndex, i_str.begin()+found));
 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; 
}
</code></pre>

blocks|key|402244|text|这对于字符串(或单个字符)分隔符应该非常有效。别忘了包括#include+<sstream>。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|402245|std::string+input+=+"Alfa=,%2BBravo=,%2BCharlie=,%2BDelta";
std::string+delimiter+=+"=,%2B";+
std::istringstream+ss(input);
std::string+token;
std::string::iterator+it;

while(std::getline(ss,+token,+*(it+=+delimiter.begin())))+{
++++std::cout+<<+token+<<+std::endl;+//+Token+is+extracted+using+'='
++++it%2B%2B;
++++//+Skip+the+rest+of+delimiter+if+exists+",%2B"
++++while(it+!=+delimiter.end()+and+ss.peek()+==+*(it))+{+
++++++++it%2B%2B;+ss.get();+
++++}
}|code-block|syntax|javascript|402246|第一个while循环使用字符串分隔符的第一个字符提取标记。第二个while循环跳过分隔符的其余部分，并在下一个标记的开头停止。|402247|entityMap^0|S|I|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

This should work perfectly for string (or single character) delimiters. Don't forget to include <code>#include &lt;sstream&gt;</code>.
<pre><code>std::string input = &quot;Alfa=,+Bravo=,+Charlie=,+Delta&quot;;
std::string delimiter = &quot;=,+&quot;; 
std::istringstream ss(input);
std::string token;
std::string::iterator it;

while(std::getline(ss, token, *(it = delimiter.begin()))) {
 std::cout &lt;&lt; token &lt;&lt; std::endl; // Token is extracted using '='
 it++;
 // Skip the rest of delimiter if exists &quot;,+&quot;
 while(it != delimiter.end() and ss.peek() == *(it)) { 
 it++; ss.get(); 
 }
}
</code></pre>
The first while loop extracts a token using the first character of the string delimiter. The second while loop skips the rest of the delimiter and stops at the beginning of the next token.

blocks|key|402275|text|功能：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|402276|std::vector<std::string>+WSJCppCore::split(const+std::string&+sWhat,+const+std::string&+sDelim)+{
++++std::vector<std::string>+vRet;
++++size_t+nPos+=+0;
++++size_t+nLen+=+sWhat.length();
++++size_t+nDelimLen+=+sDelim.length();
++++while+(nPos+<+nLen)+{
++++++++std::size_t+nFoundPos+=+sWhat.find(sDelim,+nPos);
++++++++if+(nFoundPos+!=+std::string::npos)+{
++++++++++++std::string+sToken+=+sWhat.substr(nPos,+nFoundPos+-+nPos);
++++++++++++vRet.push_back(sToken);
++++++++++++nPos+=+nFoundPos+%2B+nDelimLen;
++++++++++++if+(nFoundPos+%2B+nDelimLen+==+nLen)+{+//+last+delimiter
++++++++++++++++vRet.push_back("");
++++++++++++}
++++++++}+else+{
++++++++++++std::string+sToken+=+sWhat.substr(nPos,+nLen+-+nPos);
++++++++++++vRet.push_back(sToken);
++++++++++++break;
++++++++}
++++}
++++return+vRet;
}|code-block|syntax|javascript|402277|单元测试：|402278|bool+UnitTestSplit::run()+{
bool+bTestSuccess+=+true;

++++struct+LTest+{
++++++++LTest(
++++++++++++const+std::string+&sStr,
++++++++++++const+std::string+&sDelim,
++++++++++++const+std::vector<std::string>+&vExpectedVector
++++++++)+{
++++++++++++this->sStr+=+sStr;
++++++++++++this->sDelim+=+sDelim;
++++++++++++this->vExpectedVector+=+vExpectedVector;
++++++++};
++++++++std::string+sStr;
++++++++std::string+sDelim;
++++++++std::vector<std::string>+vExpectedVector;
++++};
++++std::vector<LTest>+tests;
++++tests.push_back(LTest("1+2+3+4+5",+"+",+{"1",+"2",+"3",+"4",+"5"}));
++++tests.push_back(LTest("%7C1f%7C2п%7C3%25%5E%7C44354%7C5kdasjfdre%7C2",+"%7C",+{"",+"1f",+"2п",+"3%25%5E",+"44354",+"5kdasjfdre",+"2"}));
++++tests.push_back(LTest("%7C1f%7C2п%7C3%25%5E%7C44354%7C5kdasjfdre%7C",+"%7C",+{"",+"1f",+"2п",+"3%25%5E",+"44354",+"5kdasjfdre",+""}));
++++tests.push_back(LTest("some1+=>+some2+=>+some3",+"=>",+{"some1+",+"+some2+",+"+some3"}));
++++tests.push_back(LTest("some1+=>+some2+=>+some3+=>",+"=>",+{"some1+",+"+some2+",+"+some3+",+""}));

++++for+(int+i+=+0;+i+<+tests.size();+i%2B%2B)+{
++++++++LTest+test+=+tests[i];
++++++++std::string+sPrefix+=+"test"+%2B+std::to_string(i)+%2B+"(\""+%2B+test.sStr+%2B+"\")";
++++++++std::vector<std::string>+vSplitted+=+WSJCppCore::split(test.sStr,+test.sDelim);
++++++++compareN(bTestSuccess,+sPrefix+%2B+":+size",+vSplitted.size(),+test.vExpectedVector.size());
++++++++int+nMin+=+std::min(vSplitted.size(),+test.vExpectedVector.size());
++++++++for+(int+n+=+0;+n+<+nMin;+n%2B%2B)+{
++++++++++++compareS(bTestSuccess,+sPrefix+%2B+",+element:+"+%2B+std::to_string(n),+vSplitted[n],+test.vExpectedVector[n]);
++++++++}
++++}

++++return+bTestSuccess;
}|402279|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Function:

<pre><code>std::vector&lt;std::string&gt; WSJCppCore::split(const std::string&amp; sWhat, const std::string&amp; sDelim) {
 std::vector&lt;std::string&gt; vRet;
 size_t nPos = 0;
 size_t nLen = sWhat.length();
 size_t nDelimLen = sDelim.length();
 while (nPos &lt; nLen) {
 std::size_t nFoundPos = sWhat.find(sDelim, nPos);
 if (nFoundPos != std::string::npos) {
 std::string sToken = sWhat.substr(nPos, nFoundPos - nPos);
 vRet.push_back(sToken);
 nPos = nFoundPos + nDelimLen;
 if (nFoundPos + nDelimLen == nLen) { // last delimiter
 vRet.push_back("");
 }
 } else {
 std::string sToken = sWhat.substr(nPos, nLen - nPos);
 vRet.push_back(sToken);
 break;
 }
 }
 return vRet;
}
</code></pre>

Unit-tests:

<pre><code>bool UnitTestSplit::run() {
bool bTestSuccess = true;

 struct LTest {
 LTest(
 const std::string &amp;sStr,
 const std::string &amp;sDelim,
 const std::vector&lt;std::string&gt; &amp;vExpectedVector
 ) {
 this-&gt;sStr = sStr;
 this-&gt;sDelim = sDelim;
 this-&gt;vExpectedVector = vExpectedVector;
 };
 std::string sStr;
 std::string sDelim;
 std::vector&lt;std::string&gt; vExpectedVector;
 };
 std::vector&lt;LTest&gt; tests;
 tests.push_back(LTest("1 2 3 4 5", " ", {"1", "2", "3", "4", "5"}));
 tests.push_back(LTest("|1f|2п|3%^|44354|5kdasjfdre|2", "|", {"", "1f", "2п", "3%^", "44354", "5kdasjfdre", "2"}));
 tests.push_back(LTest("|1f|2п|3%^|44354|5kdasjfdre|", "|", {"", "1f", "2п", "3%^", "44354", "5kdasjfdre", ""}));
 tests.push_back(LTest("some1 =&gt; some2 =&gt; some3", "=&gt;", {"some1 ", " some2 ", " some3"}));
 tests.push_back(LTest("some1 =&gt; some2 =&gt; some3 =&gt;", "=&gt;", {"some1 ", " some2 ", " some3 ", ""}));

 for (int i = 0; i &lt; tests.size(); i++) {
 LTest test = tests[i];
 std::string sPrefix = "test" + std::to_string(i) + "(\"" + test.sStr + "\")";
 std::vector&lt;std::string&gt; vSplitted = WSJCppCore::split(test.sStr, test.sDelim);
 compareN(bTestSuccess, sPrefix + ": size", vSplitted.size(), test.vExpectedVector.size());
 int nMin = std::min(vSplitted.size(), test.vExpectedVector.size());
 for (int n = 0; n &lt; nMin; n++) {
 compareS(bTestSuccess, sPrefix + ", element: " + std::to_string(n), vSplitted[n], test.vExpectedVector[n]);
 }
 }

 return bTestSuccess;
}
</code></pre>

blocks|key|402281|text|std::vector<std::string>+parse(std::string+str,std::string+delim){
++++std::vector<std::string>+tokens;
++++char+*str_c+=+strdup(str.c_str());+
++++char*+token+=+NULL;

++++token+=+strtok(str_c,+delim.c_str());+
++++while+(token+!=+NULL)+{+
++++++++tokens.push_back(std::string(token));++
++++++++token+=+strtok(NULL,+delim.c_str());+
++++}

++++delete[]+str_c;

++++return+tokens;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|402282|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>std::vector&lt;std::string&gt; parse(std::string str,std::string delim){
 std::vector&lt;std::string&gt; tokens;
 char *str_c = strdup(str.c_str()); 
 char* token = NULL;

 token = strtok(str_c, delim.c_str()); 
 while (token != NULL) { 
 tokens.push_back(std::string(token)); 
 token = strtok(NULL, delim.c_str()); 
 }

 delete[] str_c;

 return tokens;
}
</code></pre>

blocks|key|402313|text|一种非常简单/幼稚的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|402314|vector<string>+words_seperate(string+s){
++++vector<string>+ans;
++++string+w="";
++++for(auto+i:s){
++++++++if(i=='+'){
+++++++++++ans.push_back(w);
+++++++++++w="";
++++++++}
++++++++else{
+++++++++++w%2B=i;
++++++++}
++++}
++++ans.push_back(w);
++++return+ans;
}|code-block|syntax|javascript|402315|或者您可以使用boost库拆分函数：|402316|vector<string>+result;+
boost::split(result,+input,+boost::is_any_of("\t"));|402317|或者您可以尝试TOKEN或strtok：|402318|char+str[]+=+"DELIMIT-ME-C%2B%2B";+
char+*token+=+strtok(str,+"-");+
while+(token)+
{+
++++cout<<token;+
++++token+=+strtok(NULL,+"-");+
}+|402319|或者你可以这样做：|402320|char+split_with='+';
vector<string>+words;
string+token;+
stringstream+ss(our_string);
while(getline(ss+,+token+,+split_with))+words.push_back(token);|402321|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

A very simple/naive approach:
<pre><code>vector&lt;string&gt; words_seperate(string s){
 vector&lt;string&gt; ans;
 string w=&quot;&quot;;
 for(auto i:s){
 if(i==' '){
 ans.push_back(w);
 w=&quot;&quot;;
 }
 else{
 w+=i;
 }
 }
 ans.push_back(w);
 return ans;
}
</code></pre>
Or you can use boost library split function:
<pre><code>vector&lt;string&gt; result; 
boost::split(result, input, boost::is_any_of(&quot;\t&quot;));
</code></pre>
Or You can try TOKEN or strtok:
<pre><code>char str[] = &quot;DELIMIT-ME-C++&quot;; 
char *token = strtok(str, &quot;-&quot;); 
while (token) 
{ 
 cout&lt;&lt;token; 
 token = strtok(NULL, &quot;-&quot;); 
} 
</code></pre>
Or You can do this:
<pre><code>char split_with=' ';
vector&lt;string&gt; words;
string token; 
stringstream ss(our_string);
while(getline(ss , token , split_with)) words.push_back(token);
</code></pre>

blocks|key|184273|text|由于这是C%2B%2B+split+string或类似产品的最高级别的Stack+Overflow+Google搜索结果，因此我将发布一个完整的复制/粘贴可运行示例，其中演示了这两种方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|184274|splitString使用stringstream+(在大多数情况下可能是更好、更简单的选择)|184275|splitString2使用find和substr+(一种更手动的方法)|184276|//+SplitString.cpp

#include+<iostream>
#include+<vector>
#include+<string>
#include+<sstream>

//+function+prototypes
std::vector<std::string>+splitString(const+std::string&+str,+char+delim);
std::vector<std::string>+splitString2(const+std::string&+str,+char+delim);
std::string+getSubstring(const+std::string&+str,+int+leftIdx,+int+rightIdx);


int+main(void)
{
++//+Test+cases+-+all+will+pass
++
++std::string+str+=+"ab,cd,ef";
++//std::string+str+=+"abcdef";
++//std::string+str+=+"";
++//std::string+str+=+",cd,ef";
++//std::string+str+=+"ab,cd,";+++//+behavior+of+splitString+and+splitString2+is+different+for+this+final+case+only,+if+this+case+matters+to+you+choose+which+one+you+need+as+applicable
++
++
++std::vector<std::string>+tokens+=+splitString(str,+',');
++
++std::cout+<<+"tokens:+"+<<+"\n";
++
++if+(tokens.empty())
++{
++++std::cout+<<+"(tokens+is+empty)"+<<+"\n";
++}
++else
++{
++++for+(auto&+token+:+tokens)
++++{
++++++if+(token+==+"")+std::cout+<<+"(empty+string)"+<<+"\n";
++++++else+std::cout+<<+token+<<+"\n";
++++}
++}
++++
++return+0;
}

std::vector<std::string>+splitString(const+std::string&+str,+char+delim)
{
++std::vector<std::string>+tokens;
++
++if+(str+==+"")+return+tokens;
++
++std::string+currentToken;
++
++std::stringstream+ss(str);
++
++while+(std::getline(ss,+currentToken,+delim))
++{
++++tokens.push_back(currentToken);
++}
++
++return+tokens;
}

std::vector<std::string>+splitString2(const+std::string&+str,+char+delim)
{
++std::vector<std::string>+tokens;
++
++if+(str+==+"")+return+tokens;
++
++int+leftIdx+=+0;
++
++int+delimIdx+=+str.find(delim);
++
++int+rightIdx;
++
++while+(delimIdx+!=+std::string::npos)
++{
++++rightIdx+=+delimIdx+-+1;
++++
++++std::string+token+=+getSubstring(str,+leftIdx,+rightIdx);
++++tokens.push_back(token);
++++
++++//+prep+for+next+time+around
++++leftIdx+=+delimIdx+%2B+1;
++++
++++delimIdx+=+str.find(delim,+delimIdx+%2B+1);
++}
++
++rightIdx+=+str.size()+-+1;
++
++std::string+token+=+getSubstring(str,+leftIdx,+rightIdx);
++tokens.push_back(token);
++
++return+tokens;
}

std::string+getSubstring(const+std::string&+str,+int+leftIdx,+int+rightIdx)
{
++return+str.substr(leftIdx,+rightIdx+-+leftIdx+%2B+1);
}|code-block|syntax|javascript|184277|entityMap^0|4|G|0|0|B|D|C|0|0|C|E|4|J|6|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|15|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|P|$]]

Since this is the top-rated Stack Overflow Google search result for <code>C++ split string</code> or similar, I'll post a complete, copy/paste runnable example that shows both methods.
<code>splitString</code> uses <code>stringstream</code> (probably the better and easier option in most cases)
<code>splitString2</code> uses <code>find</code> and <code>substr</code> (a more manual approach)
<pre><code>// SplitString.cpp

#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;string&gt;
#include &lt;sstream&gt;

// function prototypes
std::vector&lt;std::string&gt; splitString(const std::string&amp; str, char delim);
std::vector&lt;std::string&gt; splitString2(const std::string&amp; str, char delim);
std::string getSubstring(const std::string&amp; str, int leftIdx, int rightIdx);


int main(void)
{
 // Test cases - all will pass
 
 std::string str = &quot;ab,cd,ef&quot;;
 //std::string str = &quot;abcdef&quot;;
 //std::string str = &quot;&quot;;
 //std::string str = &quot;,cd,ef&quot;;
 //std::string str = &quot;ab,cd,&quot;; // behavior of splitString and splitString2 is different for this final case only, if this case matters to you choose which one you need as applicable
 
 
 std::vector&lt;std::string&gt; tokens = splitString(str, ',');
 
 std::cout &lt;&lt; &quot;tokens: &quot; &lt;&lt; &quot;\n&quot;;
 
 if (tokens.empty())
 {
 std::cout &lt;&lt; &quot;(tokens is empty)&quot; &lt;&lt; &quot;\n&quot;;
 }
 else
 {
 for (auto&amp; token : tokens)
 {
 if (token == &quot;&quot;) std::cout &lt;&lt; &quot;(empty string)&quot; &lt;&lt; &quot;\n&quot;;
 else std::cout &lt;&lt; token &lt;&lt; &quot;\n&quot;;
 }
 }
 
 return 0;
}

std::vector&lt;std::string&gt; splitString(const std::string&amp; str, char delim)
{
 std::vector&lt;std::string&gt; tokens;
 
 if (str == &quot;&quot;) return tokens;
 
 std::string currentToken;
 
 std::stringstream ss(str);
 
 while (std::getline(ss, currentToken, delim))
 {
 tokens.push_back(currentToken);
 }
 
 return tokens;
}

std::vector&lt;std::string&gt; splitString2(const std::string&amp; str, char delim)
{
 std::vector&lt;std::string&gt; tokens;
 
 if (str == &quot;&quot;) return tokens;
 
 int leftIdx = 0;
 
 int delimIdx = str.find(delim);
 
 int rightIdx;
 
 while (delimIdx != std::string::npos)
 {
 rightIdx = delimIdx - 1;
 
 std::string token = getSubstring(str, leftIdx, rightIdx);
 tokens.push_back(token);
 
 // prep for next time around
 leftIdx = delimIdx + 1;
 
 delimIdx = str.find(delim, delimIdx + 1);
 }
 
 rightIdx = str.size() - 1;
 
 std::string token = getSubstring(str, leftIdx, rightIdx);
 tokens.push_back(token);
 
 return tokens;
}

std::string getSubstring(const std::string&amp; str, int leftIdx, int rightIdx)
{
 return str.substr(leftIdx, rightIdx - leftIdx + 1);
}
</code></pre>

blocks|key|184292|text|另外，下面是一个易于使用的拆分函数和宏的代码示例，您可以在其中选择容器类型：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|184293|#include+<iostream>
#include+<vector>
#include+<string>

#define+split(str,+delim,+type)+(split_fn<type<std::string>>(str,+delim))
+
template+<typename+Container>
Container+split_fn(const+std::string&+str,+char+delim+=+'+')+{
++++Container+cont{};
++++std::size_t+current,+previous+=+0;
++++current+=+str.find(delim);
++++while+(current+!=+std::string::npos)+{
++++++++cont.push_back(str.substr(previous,+current+-+previous));
++++++++previous+=+current+%2B+1;
++++++++current+=+str.find(delim,+previous);
++++}
++++cont.push_back(str.substr(previous,+current+-+previous));
++++
++++return+cont;
}

int+main()+{
++++
++++auto+test+=+std::string{"This+is+a+great+test"};
++++auto+res+=+split(test,+'+',+std::vector);
++++
++++for(auto+&i+:+res)+{
++++++++std::cout+<<+i+<<+",+";+//+"this",+"is",+"a",+"great",+"test"
++++}
++++
++++
++++return+0;
}|code-block|syntax|javascript|184294|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

As a bonus, here is a code example of a split function and macro that is easy to use and where you can choose the container type :
<pre><code>#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;string&gt;

#define split(str, delim, type) (split_fn&lt;type&lt;std::string&gt;&gt;(str, delim))
 
template &lt;typename Container&gt;
Container split_fn(const std::string&amp; str, char delim = ' ') {
 Container cont{};
 std::size_t current, previous = 0;
 current = str.find(delim);
 while (current != std::string::npos) {
 cont.push_back(str.substr(previous, current - previous));
 previous = current + 1;
 current = str.find(delim, previous);
 }
 cont.push_back(str.substr(previous, current - previous));
 
 return cont;
}

int main() {
 
 auto test = std::string{&quot;This is a great test&quot;};
 auto res = split(test, ' ', std::vector);
 
 for(auto &amp;i : res) {
 std::cout &lt;&lt; i &lt;&lt; &quot;, &quot;; // &quot;this&quot;, &quot;is&quot;, &quot;a&quot;, &quot;great&quot;, &quot;test&quot;
 }
 
 
 return 0;
}
</code></pre>

blocks|key|184304|text|您还可以使用正则表达式来执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|184305|std::vector<std::string>+split(const+std::string+str,+const+std::string+regex_str)
{
++++std::regex+regexz(regex_str);
++++std::vector<std::string>+list(std::sregex_token_iterator(str.begin(),+str.end(),+regexz,+-1),
++++++++++++++++++++++++++++++++++std::sregex_token_iterator());
++++return+list;
}|code-block|syntax|javascript|184306|相当于：|184307|std::vector<std::string>+split(const+std::string+str,+const+std::string+regex_str)
{
++++std::sregex_token_iterator+token_iter(str.begin(),+str.end(),+regexz,+-1);
++++std::sregex_token_iterator+end;
++++std::vector<std::string>+list;
++++while+(token_iter+!=+end)
++++{
++++++++list.emplace_back(*token_iter%2B%2B);
++++}
++++return+list;
}|184308|并像这样使用它：|184309|#include+<iostream>
#include+<string>
#include+<regex>

std::vector<std::string>+split(const+std::string+str,+const+std::string+regex_str)
{+++//+a+yet+more+concise+form!
++++return+{+std::sregex_token_iterator(str.begin(),+str.end(),+std::regex(regex_str),+-1),+std::sregex_token_iterator()+};
}

int+main()
{
++++std::string+input_str+=+"lets+split+this";
++++std::string+regex_str+=+"+";+
++++auto+tokens+=+split(input_str,+regex_str);
++++for+(auto&+item:+tokens)
++++{
++++++++std::cout<<item+<<std::endl;
++++}
}|184310|在线玩吧！http://cpp.sh/9sumb|offset|length|184311|您可以简单地使用子字符串、字符等，就像normal一样，或者使用实际的正则表达式进行拆分。|184312|它也是简洁和C%2B%2B11的！|184313|entityMap|0|LINK|mutability|MUTABLE|url|http://cpp.sh/9sumb^0|0|0|0|0|0|0|5|J|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1A|8|@]|9|@$Q|1B|R|1C|1|1D]]|A|$]]|$1|S|3|T|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1F|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]]]

You can also use regex for this:
<pre class="lang-cpp prettyprint-override"><code>std::vector&lt;std::string&gt; split(const std::string str, const std::string regex_str)
{
 std::regex regexz(regex_str);
 std::vector&lt;std::string&gt; list(std::sregex_token_iterator(str.begin(), str.end(), regexz, -1),
 std::sregex_token_iterator());
 return list;
}
</code></pre>
which is equivalent to :
<pre class="lang-cpp prettyprint-override"><code>std::vector&lt;std::string&gt; split(const std::string str, const std::string regex_str)
{
 std::sregex_token_iterator token_iter(str.begin(), str.end(), regexz, -1);
 std::sregex_token_iterator end;
 std::vector&lt;std::string&gt; list;
 while (token_iter != end)
 {
 list.emplace_back(*token_iter++);
 }
 return list;
}

</code></pre>
and use it like this :
<pre class="lang-cpp prettyprint-override"><code>#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;regex&gt;

std::vector&lt;std::string&gt; split(const std::string str, const std::string regex_str)
{ // a yet more concise form!
 return { std::sregex_token_iterator(str.begin(), str.end(), std::regex(regex_str), -1), std::sregex_token_iterator() };
}

int main()
{
 std::string input_str = &quot;lets split this&quot;;
 std::string regex_str = &quot; &quot;; 
 auto tokens = split(input_str, regex_str);
 for (auto&amp; item: tokens)
 {
 std::cout&lt;&lt;item &lt;&lt;std::endl;
 }
}

</code></pre>
play with it online! <a href="http://cpp.sh/9sumb" rel="noreferrer">http://cpp.sh/9sumb</a>
you can simply use substrings, characters, etc like normal, or use actual regular expressions to do the splitting. 
its also concise and C++11!

blocks|key|184317|text|template<typename+C,+typename+T>
auto+insert_in_container(C&+c,+T&&+t)+->+decltype(c.push_back(std::forward<T>(t)),+void())+{
++++c.push_back(std::forward<T>(t));
}
template<typename+C,+typename+T>
auto+insert_in_container(C&+c,+T&&+t)+->+decltype(c.insert(std::forward<T>(t)),+void())+{
++++c.insert(std::forward<T>(t));
}
template<typename+Container>
Container+splitR(const+std::string&+input,+const+std::string&+delims)+{
++++Container+out;
++++size_t+delims_len+=+delims.size();
++++auto+begIdx+=+0u;
++++auto+endIdx+=+input.find(delims,+begIdx);
++++if+(endIdx+==+std::string::npos+&&+input.size()+!=+0u)+{
++++++++insert_in_container(out,+input);
++++}
++++else+{
++++++++size_t+w+=+0;
++++++++while+(endIdx+!=+std::string::npos)+{
++++++++++++w+=+endIdx+-+begIdx;
++++++++++++if+(w+!=+0)+insert_in_container(out,+input.substr(begIdx,+w));
++++++++++++begIdx+=+endIdx+%2B+delims_len;
++++++++++++endIdx+=+input.find(delims,+begIdx);
++++++++}
++++++++w+=+input.length()+-+begIdx;
++++++++if+(w+!=+0)+insert_in_container(out,+input.substr(begIdx,+w));
++++}
++++return+out;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|184318|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>template&lt;typename C, typename T&gt;
auto insert_in_container(C&amp; c, T&amp;&amp; t) -&gt; decltype(c.push_back(std::forward&lt;T&gt;(t)), void()) {
 c.push_back(std::forward&lt;T&gt;(t));
}
template&lt;typename C, typename T&gt;
auto insert_in_container(C&amp; c, T&amp;&amp; t) -&gt; decltype(c.insert(std::forward&lt;T&gt;(t)), void()) {
 c.insert(std::forward&lt;T&gt;(t));
}
template&lt;typename Container&gt;
Container splitR(const std::string&amp; input, const std::string&amp; delims) {
 Container out;
 size_t delims_len = delims.size();
 auto begIdx = 0u;
 auto endIdx = input.find(delims, begIdx);
 if (endIdx == std::string::npos &amp;&amp; input.size() != 0u) {
 insert_in_container(out, input);
 }
 else {
 size_t w = 0;
 while (endIdx != std::string::npos) {
 w = endIdx - begIdx;
 if (w != 0) insert_in_container(out, input.substr(begIdx, w));
 begIdx = endIdx + delims_len;
 endIdx = input.find(delims, begIdx);
 }
 w = input.length() - begIdx;
 if (w != 0) insert_in_container(out, input.substr(begIdx, w));
 }
 return out;
}
</code></pre>

blocks|key|402500|text|我提出了这个解决方案。这很简单，所有的print/value都在循环中(不需要在循环之后检查)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|402501|#include+<iostream>
#include+<string>

using+std::cout;
using+std::string;

int+main()+{
++++string+s+=+"it-%2Bis-%2Bworking!";
++++string+d+=+"-%2B";

++++int+firstFindI+=+0;
++++int+secendFindI+=+s.find(d,+0);+//+find+if+have+any+at+all
++++while+(secendFindI+!=+string::npos)
++++{
++++++++secendFindI+=+s.find(d,+firstFindI);
++++++++cout+<<+s.substr(firstFindI,+secendFindI+-+firstFindI)+<<+"\n";+//+print+sliced+part
++++++++firstFindI+=+secendFindI+%2B+d.size();+//+add+to+the+search+index
++++}

}|code-block|syntax|javascript|402502|这种解决方案的唯一缺点是在开始时进行两次搜索。|402503|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I make this solution. It is very simple, all the prints/values are in the loop (no need to check after the loop).
<pre><code>#include &lt;iostream&gt;
#include &lt;string&gt;

using std::cout;
using std::string;

int main() {
 string s = &quot;it-+is-+working!&quot;;
 string d = &quot;-+&quot;;

 int firstFindI = 0;
 int secendFindI = s.find(d, 0); // find if have any at all
 while (secendFindI != string::npos)
 {
 secendFindI = s.find(d, firstFindI);
 cout &lt;&lt; s.substr(firstFindI, secendFindI - firstFindI) &lt;&lt; &quot;\n&quot;; // print sliced part
 firstFindI = secendFindI + d.size(); // add to the search index
 }

}
</code></pre>
The only downside of this solution is that is doing a search twice in the start.

blocks|key|184426|text|我使用指针算法。inner+for+string+delimeter如果您对char+delim感到满意，只需简单地删除inner即可。我希望它是正确的。如果您注意到任何错误或改进，请留下评论。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|184427|std::vector<std::string>+split(std::string+s,+std::string+delim)
{
++++char+*p+=+&s[0];
++++char+*d+=+&delim[0];
++++std::vector<std::string>+res+=+{""};

++++do
++++{
++++++++bool+is_delim+=+true;
++++++++char+*pp+=+p;
++++++++char+*dd+=+d;
++++++++while+(*dd+&&+is_delim+==+true)
++++++++++++if+(*pp%2B%2B+!=+*dd%2B%2B)
++++++++++++++++is_delim+=+false;

++++++++if+(is_delim)
++++++++{
++++++++++++p+=+pp+-+1;
++++++++++++res.push_back("");
++++++++}
++++++++else
++++++++++++*(res.rbegin())+%2B=+*p;
++++}+while+(*p%2B%2B);

++++return+res;
}|code-block|syntax|javascript|184428|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

i use pointer arithmetic. inner while for string delimeter if you satify with char delim just remove inner while simply. i hope it is correct. if you notice any mistake or improve please leave the comment.
<pre><code>std::vector&lt;std::string&gt; split(std::string s, std::string delim)
{
 char *p = &amp;s[0];
 char *d = &amp;delim[0];
 std::vector&lt;std::string&gt; res = {&quot;&quot;};

 do
 {
 bool is_delim = true;
 char *pp = p;
 char *dd = d;
 while (*dd &amp;&amp; is_delim == true)
 if (*pp++ != *dd++)
 is_delim = false;

 if (is_delim)
 {
 p = pp - 1;
 res.push_back(&quot;&quot;);
 }
 else
 *(res.rbegin()) += *p;
 } while (*p++);

 return res;
}
</code></pre>

blocks|key|402594|text|下面是一个简洁的拆分函数。我决定让back+to+back分隔符作为空字符串返回，但您可以很容易地检查子字符串是否为空，如果为空，则不将其添加到向量中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|402595|#include+<vector>
#include+<string>
using+namespace+std;



vector<string>+split(string+to_split,+string+delimiter)+{
++++size_t+pos+=+0;
++++vector<string>+matches{};
++++do+{
++++++++pos+=+to_split.find(delimiter);
++++++++int+change_end;
++++++++if+(pos+==+string::npos)+{
++++++++++++pos+=+to_split.length()+-+1;
++++++++++++change_end+=+1;
++++++++}
++++++++else+{
++++++++++++change_end+=+0;
++++++++}
++++++++matches.push_back(to_split.substr(0,+pos%2Bchange_end));
++++++++
++++++++to_split.erase(0,+pos%2B1);

++++}
++++while+(!to_split.empty());
++++return+matches;

}|code-block|syntax|javascript|402596|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a concise split function. I decided to have back to back delimiters return as an empty string but you could easily check that if the substring is empty and not add it to the vector if it is.
<pre><code>#include &lt;vector&gt;
#include &lt;string&gt;
using namespace std;



vector&lt;string&gt; split(string to_split, string delimiter) {
 size_t pos = 0;
 vector&lt;string&gt; matches{};
 do {
 pos = to_split.find(delimiter);
 int change_end;
 if (pos == string::npos) {
 pos = to_split.length() - 1;
 change_end = 1;
 }
 else {
 change_end = 0;
 }
 matches.push_back(to_split.substr(0, pos+change_end));
 
 to_split.erase(0, pos+1);

 }
 while (!to_split.empty());
 return matches;

}
</code></pre>

blocks|key|402632|text|一种用C%2B%2B20实现的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|402633|#include+<iostream>
#include+<ranges>
#include+<string_view>

int+main()
{
++++std::string+hello+=+"text+to+be+parsed";
++++auto+split+=+hello
++++++++%7C+std::ranges::views::split('+')
++++++++%7C+std::ranges::views::transform([](auto&&+str)+{+return+std::string_view(&*str.begin(),+std::ranges::distance(str));+});

++++for+(auto&&+word+:+split)
++++{
++++++++std::cout+<<+word+<<+std::endl;
++++}
}|code-block|syntax|javascript|402634|请参阅：https://stackoverflow.com/a/48403210/10771848+https://en.cppreference.com/w/cpp/ranges/split_view|offset|length|402635|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/48403210/10771848|1|https://en.cppreference.com/w/cpp/ranges/split_view^0|0|0|4|19|0|1E|1F|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@$I|X|J|Y|1|Z]|$I|10|J|11|1|12]]|A|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]|S|$5|N|O|P|A|$Q|T]]]]

A way of doing it with C++20 :
<pre class="lang-cpp prettyprint-override"><code>#include &lt;iostream&gt;
#include &lt;ranges&gt;
#include &lt;string_view&gt;

int main()
{
 std::string hello = &quot;text to be parsed&quot;;
 auto split = hello
 | std::ranges::views::split(' ')
 | std::ranges::views::transform([](auto&amp;&amp; str) { return std::string_view(&amp;*str.begin(), std::ranges::distance(str)); });

 for (auto&amp;&amp; word : split)
 {
 std::cout &lt;&lt; word &lt;&lt; std::endl;
 }
}
</code></pre>
See :
<a href="https://stackoverflow.com/a/48403210/10771848">https://stackoverflow.com/a/48403210/10771848</a>
<a href="https://en.cppreference.com/w/cpp/ranges/split_view" rel="noreferrer">https://en.cppreference.com/w/cpp/ranges/split_view</a>

blocks|key|184570|text|这与其他答案类似，但它使用的是string_view。所以这些只是原始字符串的视图。类似于c%2B%2B20示例。尽管这将是一个c%2B%2B17示例。(编辑以跳过空匹配项)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|184571|#include+<algorithm>
#include+<iostream>
#include+<string_view>
#include+<vector>
std::vector<std::string_view>+split(std::string_view+buffer,
++++++++++++++++++++++++++++++++++++const+std::string_view+delimeter+=+"+")+{
++std::vector<std::string_view>+ret{};
++std::decay_t<decltype(std::string_view::npos)>+pos{};
++while+((pos+=+buffer.find(delimeter))+!=+std::string_view::npos)+{
++++const+auto+match+=+buffer.substr(0,+pos);
++++if+(!match.empty())+ret.push_back(match);
++++buffer+=+buffer.substr(pos+%2B+delimeter.size());
++}
++if+(!buffer.empty())+ret.push_back(buffer);
++return+ret;
}
int+main()+{
++const+auto+split_values+=+split("1+2+3+4+5+6+7+8+9+++++10+");
++std::for_each(split_values.begin(),+split_values.end(),
++++++++++++++++[](const+auto&+str)+{+std::cout+<<+str+<<+'\n';+});
++return+split_values.size();
}|code-block|syntax|javascript|184572|entityMap^0|F|B|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

This is similar to other answers but it's using <code>string_view</code>. So these are just views for the original string. Similar to the c++20 example. Though this would be a c++17 example. (edit to skip empty matches)
<pre><code>#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;string_view&gt;
#include &lt;vector&gt;
std::vector&lt;std::string_view&gt; split(std::string_view buffer,
 const std::string_view delimeter = &quot; &quot;) {
 std::vector&lt;std::string_view&gt; ret{};
 std::decay_t&lt;decltype(std::string_view::npos)&gt; pos{};
 while ((pos = buffer.find(delimeter)) != std::string_view::npos) {
 const auto match = buffer.substr(0, pos);
 if (!match.empty()) ret.push_back(match);
 buffer = buffer.substr(pos + delimeter.size());
 }
 if (!buffer.empty()) ret.push_back(buffer);
 return ret;
}
int main() {
 const auto split_values = split(&quot;1 2 3 4 5 6 7 8 9 10 &quot;);
 std::for_each(split_values.begin(), split_values.end(),
 [](const auto&amp; str) { std::cout &lt;&lt; str &lt;&lt; '\n'; });
 return split_values.size();
}
</code></pre>

blocks|key|402678|text|为了以防万一，将来有人想要Vincenzo+Pii答案的开箱即用功能|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|402679|#include+<vector>
#include+<string>


std::vector<std::string>+SplitString(
++++std::string+str,
++++std::string+delimeter)
{
++++std::vector<std::string>+splittedStrings+=+{};
++++size_t+pos+=+0;

++++while+((pos+=+str.find(delimeter))+!=+std::string::npos)
++++{
++++++++std::string+token+=+str.substr(0,+pos);
++++++++if+(token.length()+>+0)
++++++++++++splittedStrings.push_back(token);
++++++++str.erase(0,+pos+%2B+delimeter.length());
++++}

++++if+(str.length()+>+0)
++++++++splittedStrings.push_back(str);
++++return+splittedStrings;
}|code-block|syntax|javascript|402680|我还修复了一些错误，以便在字符串的开头或结尾有分隔符时，函数不会返回空字符串|402681|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/528313/vincenzo-pii^0|D|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Just in case in the future, someone wants out of the box function of <a href="https://stackoverflow.com/users/528313/vincenzo-pii">Vincenzo Pii</a> 's answer
<pre><code>#include &lt;vector&gt;
#include &lt;string&gt;


std::vector&lt;std::string&gt; SplitString(
 std::string str,
 std::string delimeter)
{
 std::vector&lt;std::string&gt; splittedStrings = {};
 size_t pos = 0;

 while ((pos = str.find(delimeter)) != std::string::npos)
 {
 std::string token = str.substr(0, pos);
 if (token.length() &gt; 0)
 splittedStrings.push_back(token);
 str.erase(0, pos + delimeter.length());
 }

 if (str.length() &gt; 0)
 splittedStrings.push_back(str);
 return splittedStrings;
}
</code></pre>
I also fixed some bugs so that the function won't return an empty string if there is a delimiter at the start or the end of the string

I am parsing a string in C++ using the following:

<pre><code>using namespace std;

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

if (getline(input_stringstream,parsed,' '))
{
 // do some processing.
}
</code></pre>

Parsing with a single char delimiter is fine. But what if I want to use a string as delimiter.

Example: I want to split:

<pre><code>scott&gt;=tiger
</code></pre>

with <code>&gt;=</code> as delimiter so that I can get scott and tiger.

Parse (split) a string in C++ using string delimiter (standard C++)

单元测试

容器

我正在使用以下代码解析C++中的字符串：using namespace std;string parsed,input="text to be parsed";stringstream input_stringstream(input);if (getline(input_stringstream,parsed,' '...

问使用字符串分隔符(标准C++)解析(拆分) C++中的字符串
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用字符串分隔符(标准C++)解析(拆分) C++中的字符串EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用字符串分隔符(标准C++)解析(拆分) C++中的字符串
EN