使用字符串分隔符（标准 C++）在 C++ 中解析（拆分）字符串
Posted
技术标签:
【中文标题】使用字符串分隔符（标准 C++）在 C++ 中解析（拆分）字符串【英文标题】：Parse (split) a string in C++ using string delimiter (standard C++) 【发布时间】：2012-12-25 07:01:11 【问题描述】：我正在使用以下代码在 C++ 中解析一个字符串：
using namespace std;
string parsed,input="text to be parsed";
stringstream input_stringstream(input);
if (getline(input_stringstream,parsed,' '))
// do some processing.
使用单个字符分隔符进行解析很好。但是如果我想使用字符串作为分隔符呢？
示例：我要拆分：
scott>=tiger
用>= 作为分隔符，这样我就可以得到scott 和tiger。
【问题讨论】：
***.blog/2019/10/11/… 向下滚动到 #5。 看这个question用c++20实现读取文件和拆分字符串。 【参考方案1】：您可以使用std::string::find() 函数查找字符串分隔符的位置，然后使用std::string::substr() 获取令牌。
例子：
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。
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 << token << std::endl;
s.erase(0, pos + delimiter.length());
std::cout << s << std::endl;
输出：
scott
tiger
mushroom
【讨论】：
不想修改输入字符串的可以size_t last = 0; size_t next = 0; while ((next = s.find(delimiter, last)) != string::npos) cout << s.substr(last, next-last) << endl; last = next + 1; cout << s.substr(last) << endl;
注意：mushroom 在循环外输出，即s = mushroom
这些样本不会从字符串中提取最后一个标记。我从一个字符串中提取 IpV4 的示例： size_t last = 0; size_t 下一个 = 0;整数索引 = 0； while (index
@hayk.mart 请注意，如下所示，由于分隔符的大小为 2 个字符，您需要添加 2 而不是 1 :) : std::string s = "scott >=老虎>=蘑菇"; std::string 分隔符 = ">="; size_t 最后 = 0; size_t 下一个 = 0; while ((next = s.find(delimiter, last)) != std::string::npos) std::cout
想知道 615 位支持者中有多少人错过了最后一行，并且在他们的生产代码中运行隐藏的错误。从 cmets 来看，我至少会赌一把。如果不使用 cout 而是将其显示为函数，IMO 这个答案会更合适。【参考方案2】：
此方法使用std::string::find，不会通过记住前一个子字符串标记的开头和结尾来改变原始字符串。
#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 + delim.length();
end = s.find(delim, start);
std::cout << s.substr(start, end);
【讨论】：
如何对vectors.substr(start, end - start) 吗？我想这只适用于start + end > size()，因此它总是需要the rest of the string ...
由于end == std::string::npos，表示我们要返回最终的token。
最后一行可以进一步简化为s.substr(start) ，无需指定长度，因为如果省略长度，它将提取整个训练子串。【参考方案3】：
用于字符串分隔符
根据字符串分隔符分割字符串。如根据字符串分隔符"-+"拆分字符串"adsf-+qwret-+nvfkbdsj-+orthdfjgh-+dfjrleih"，输出为"adsf", "qwret", "nvfkbdsj", "orthdfjgh", "dfjrleih"
#include <iostream>
#include <sstream>
#include <vector>
using namespace std;
// for string delimiter
vector<string> split (string s, string delimiter)
size_t pos_start = 0, pos_end, delim_len = delimiter.length();
string token;
vector<string> 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<string> v = split (str, delimiter);
for (auto i : v) cout << i << endl;
return 0;
输出
广告 qwret nvfkbdsj 正值 dfjrleih单字符分隔符
根据字符分隔符拆分字符串。比如用分隔符"+"分割字符串"adsf+qwer+poui+fdgh"会输出"adsf", "qwer", "poui", "fdg"h
#include <iostream>
#include <sstream>
#include <vector>
using namespace std;
vector<string> split (const string &s, char delim)
vector<string> result;
stringstream ss (s);
string item;
while (getline (ss, item, delim))
result.push_back (item);
return result;
int main()
string str = "adsf+qwer+poui+fdgh";
vector<string> v = split (str, '+');
for (auto i : v) cout << i << endl;
return 0;
输出
广告 qwer 呸呸呸 fdgh【讨论】：
你返回vector<string> 我想它会调用复制构造函数。
我看到的每个引用都表明，在该上下文中消除了对复制构造函数的调用。
使用“现代”（C++03？）编译器我相信这是正确的，RVO 和/或移动语义将消除复制构造函数。
我尝试了单字符分隔符，如果字符串以分隔符结尾（即行尾的空 csv 列），它不会返回空字符串。它只是返回少一个字符串。例如：1,2,3,4\nA,B,C,
我也尝试过用于字符串分隔符的，如果字符串以分隔符结尾，则最后一个分隔符成为最后提取的字符串的一部分。【参考方案4】：
你可以使用 next 函数来分割字符串：
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 + delim.length();
while (pos < str.length() && prev < str.length());
return tokens;
【讨论】：
IMO 它没有按预期工作：split("abc","a") 将返回一个向量或单个字符串"bc"，我认为如果它返回一个元素向量会更有意义@ 987654324@。在 Python 中使用str.split()，对我来说很直观，它应该返回一个空字符串，以防在开头或结尾找到delim，但这只是我的意见。反正我就是觉得应该提一下
强烈建议删除if (!token.empty()) 以防止@kyriakosSt 提到的问题以及与连续分隔符相关的其他问题。
如果可以的话，我会删除我的赞成票，但我不会让我这样做。 @kyriakosSt 提出的问题是个问题，删除 if (!token.empty()) 似乎不足以解决它。
@bhaller 这个片段的设计目的是为了跳过空片段。如果您需要保留空的，恐怕您需要编写另一个拆分实现。为了社区的利益，请建议您在这里发布。【参考方案5】：
您也可以为此使用正则表达式：
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;
相当于：
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++);
return list;
并像这样使用它：
#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;
在线玩！ http://cpp.sh/9sumb
您可以像平常一样简单地使用子字符串、字符等，或者使用实际的正则表达式来进行拆分。 它也简洁和 C++11！
【讨论】：
这应该是正确的答案，前提是 C++11 在桌面上，如果不是......你应该使用 C++>=11，它是一个游戏规则改变者！ 能否解释一下函数split()中的return语句？我试图弄清楚令牌是如何被推入std::vector 容器的。谢谢。
将它写成return std::vector<std::string> std::sregex_token_iterator(str.begin(), str.end(), std::regex(regex_str), -1), std::sregex_token_iterator() ; 会让您更清楚如何创建和返回临时std::vector 吗？我们在这里使用列表初始化。看看here
@DeusXMachina：当然是一个很好的解决方案。一个警告：“更简洁的形式！”在最后一个代码段中，_LIBCPP_STD_VER > 11 不会编译，因为该方法被标记为“删除”......但早期的代码段不隐式需要右值引用 && 在 C++2a 下编译和运行良好。
@Rika 是的，这行得通。感谢您的帮助。【参考方案6】：
使用 C++20 的一种方法：
#include <iostream>
#include <ranges>
#include <string_view>
int main()
std::string hello = "text to be parsed";
auto split = hello
| std::ranges::views::split(' ')
| 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;
见：https://***.com/a/48403210/10771848https://en.cppreference.com/w/cpp/ranges/split_view
【讨论】：
【参考方案7】：此代码从文本中拆分行，并将每个人添加到向量中。
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 + delimiter.length());
list.push_back(s);
return list;
调用者：
vector<string> listFilesMax = split(buffer, "\n");
【讨论】：
效果很好！我添加了 list.push_back(s);因为它不见了。 它错过了字符串的最后一部分。 while循环结束后，我们需要将s的剩余部分添加为新的token。 我已对代码示例进行了编辑以修复缺少的 push_back。 会更好vector<string> split(char *phrase, const string delimiter="\n")
我知道有点晚了，但是如果在 push if (token != "") list.push_back(token); 之前添加这个 if 语句会更好地防止附加空字符串。【参考方案8】：
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());
【讨论】：
谢谢。但我只想使用 C++ 而不是像strtok() 这样的任何 C 函数，因为它需要我使用 char 数组而不是字符串。
@TheCrazyProgrammer 所以？如果 C 函数可以满足您的需求，请使用它。这不是一个 C 函数在 C++ 中不可用的世界（事实上，它们必须如此）。 .c_str() 既便宜又简单。
如果字符串中有重复元素，则检查 if(token != mystring) 会给出错误结果。我用你的代码制作了一个没有这个的版本。它有许多从根本上改变答案的变化，所以我写了自己的答案而不是编辑。在下面检查。【参考方案9】：
Answer 已经存在，但是 selected-answer 使用擦除功能非常昂贵，想想一些非常大的字符串（以 MB 为单位）。因此我使用下面的函数。
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()+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;
【讨论】：
我对此进行了测试，它确实有效。谢谢！在我看来，这是最好的答案，因为正如原始回答者所说，这种解决方案减少了内存开销，并且结果方便地存储在向量中。 （复制 Pythonstring.split() 方法。）【参考方案10】：
我会使用boost::tokenizer。这是解释如何制作适当的标记器功能的文档：http://www.boost.org/doc/libs/1_52_0/libs/tokenizer/tokenizerfunction.htm
这里有一个适合你的情况。
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 + 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';
【讨论】：
谢谢。但我只希望标准 C++ 而不是第三方库。 @TheCrazyProgrammer：好的，当我阅读“标准 C++”时，我认为这意味着没有非标准扩展，并不是说你不能使用符合标准的第三方库。【参考方案11】：这是我对此的看法。它处理边缘情况并采用可选参数从结果中删除空条目。
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 + 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]()
【讨论】：
【参考方案12】：这对于字符串（或单个字符）分隔符应该非常有效。不要忘记包含#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())))
std::cout << token << std::endl; // Token is extracted using '='
it++;
// Skip the rest of delimiter if exists ",+"
while(it != delimiter.end() and ss.peek() == *(it))
it++; ss.get();
第一个 while 循环使用字符串分隔符的第一个字符提取标记。第二个 while 循环跳过分隔符的其余部分并在下一个标记的开头停止。
【讨论】：
这是不正确的。如果输入被修改如下，它将使用第一个 = 进行拆分，而不应该这样做：std::string input = "Alfa=,+Bravo=,+Charlie=,+Delta=Echo";
@Amitoj 很好。我修改了我的答案，甚至涵盖了带有错误分隔符的输入。【参考方案13】：
这是一个完整的方法，可以在任何分隔符上拆分字符串并返回切碎的字符串的向量。
这是对 ryanbwork 答案的改编。但是，如果您的字符串中有重复元素，他的检查：if(token != mystring) 会给出错误的结果。这是我解决这个问题的方法。
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) + 1);
subStringList.push_back(token);
return subStringList;
【讨论】：
像while (true) 这样的东西在这样的一段代码中看到通常很可怕。我个人建议重写它，以便与std::string::npos 的比较（或分别与mystring.size() 的检查）使while (true) 过时。【参考方案14】：
一个非常简单/幼稚的方法：
vector<string> words_seperate(string s)
vector<string> ans;
string w="";
for(auto i:s)
if(i==' ')
ans.push_back(w);
w="";
else
w+=i;
ans.push_back(w);
return ans;
或者你可以使用boost库拆分功能：
vector<string> result;
boost::split(result, input, boost::is_any_of("\t"));
或者你可以试试TOKEN或者strtok：
char str[] = "DELIMIT-ME-C++";
char *token = strtok(str, "-");
while (token)
cout<<token;
token = strtok(NULL, "-");
或者你可以这样做：
char split_with=' ';
vector<string> words;
string token;
stringstream ss(our_string);
while(getline(ss , token , split_with)) words.push_back(token);
【讨论】：
【参考方案15】：由于这是 C++ split string 或类似的最高评价的 Stack Overflow Google 搜索结果，我将发布一个完整的、复制/粘贴可运行的示例，显示这两种方法。
splitString 使用 stringstream（在大多数情况下可能是更好、更简单的选择）
splitString2 使用 find 和 substr（更手动的方法）
// 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 + 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& str, int leftIdx, int rightIdx)
return str.substr(leftIdx, rightIdx - leftIdx + 1);
【讨论】：
【参考方案16】：又一个答案：这里我使用find_first_not_of 字符串函数，它返回第一个字符的位置，不 匹配中指定的任何字符分隔符。
size_t find_first_not_of(const string& delim, size_t pos = 0) const noexcept;
例子：
int main()
size_t start = 0, end = 0;
std::string str = "scott>=tiger>=cat";
std::string delim = ">=";
while ((start = str.find_first_not_of(delim, end)) != std::string::npos)
end = str.find(delim, start); // finds the 'first' occurance from the 'start'
std::cout << str.substr(start, end - start)<<std::endl; // extract substring
return 0;
输出：
scott
tiger
cat
【讨论】：
【参考方案17】：我提出了这个解决方案。很简单，所有的打印/值都在循环中（循环后不需要检查）。
#include <iostream>
#include <string>
using std::cout;
using std::string;
int main()
string s = "it-+is-+working!";
string d = "-+";
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 + d.size(); // add to the search index
此解决方案的唯一缺点是在开始时进行两次搜索。
【讨论】：
【参考方案18】：这与其他答案类似，但使用的是string_view。所以这些只是原始字符串的视图。类似于 c++20 示例。虽然这将是一个 c++17 示例。 （编辑以跳过空匹配）
#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 + 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();
【讨论】：
【参考方案19】：如果您不想修改字符串（如 Vincenzo Pii 的回答）并且也想输出最后一个标记，您可能需要使用这种方法：
inline std::vector<std::string> splitString( const std::string &s, const std::string &delimiter )
std::vector<std::string> 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 << token << std::endl;
while ( end != std::string::npos );
return ret;
【讨论】：
【参考方案20】：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;
【讨论】：
【参考方案21】：这是一个简洁的拆分函数。我决定让背靠背分隔符作为空字符串返回，但您可以轻松检查子字符串是否为空，如果是则不将其添加到向量中。
#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+change_end));
to_split.erase(0, pos+1);
while (!to_split.empty());
return matches;
【讨论】：
【参考方案22】：以防万一将来有人想要Vincenzo Pii的答案的开箱即用功能
#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 + delimeter.length());
if (str.length() > 0)
splittedStrings.push_back(str);
return splittedStrings;
我还修复了一些错误，如果字符串的开头或结尾有分隔符，函数将不会返回空字符串
【讨论】：
【参考方案23】：#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+=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<x;i++)
cout<<res[i]<<endl;
return 0;
P.S：只有在拆分后的字符串长度相等时才有效
【讨论】：
这个使用GCC扩展——变长数组。【参考方案24】：功能：
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 + 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;
单元测试：
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("|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 => some2 => some3", "=>", "some1 ", " some2 ", " some3"));
tests.push_back(LTest("some1 => some2 => some3 =>", "=>", "some1 ", " some2 ", " some3 ", ""));
for (int i = 0; i < tests.size(); i++)
LTest test = tests[i];
std::string sPrefix = "test" + std::to_string(i) + "(\"" + test.sStr + "\")";
std::vector<std::string> 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 < nMin; n++)
compareS(bTestSuccess, sPrefix + ", element: " + std::to_string(n), vSplitted[n], test.vExpectedVector[n]);
return bTestSuccess;
【讨论】：
【参考方案25】：作为奖励，这是一个易于使用的拆分函数和宏的代码示例，您可以在其中选择容器类型：
#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 + 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;
【讨论】：
【参考方案26】：我使用指针算法。如果您使用 char delim 来满足字符串分隔符的 inner while ，则只需简单地删除 inner while 。我希望它是正确的。如果您发现任何错误或改进，请发表评论。
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++ != *dd++)
is_delim = false;
if (is_delim)
p = pp - 1;
res.push_back("");
else
*(res.rbegin()) += *p;
while (*p++);
return res;
【讨论】：
欢迎来到 Stack Overflow。虽然这段代码可以解决问题，including an explanation 解决问题的方式和原因确实有助于提高帖子的质量，并可能导致更多的赞成票。请记住，您正在为将来的读者回答问题，而不仅仅是现在提问的人。请编辑您的答案以添加解释并说明适用的限制和假设。【参考方案27】：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 + delims_len;
endIdx = input.find(delims, begIdx);
w = input.length() - begIdx;
if (w != 0) insert_in_container(out, input.substr(begIdx, w));
return out;
【讨论】：
【参考方案28】：从 C++11 开始可以这样：
std::vector<std::string> splitString(const std::string& str,
const std::regex& regex)
return std::sregex_token_iteratorstr.begin(), str.end(), regex, -1,
std::sregex_token_iterator() ;
// usually we have a predefined set of regular expressions: then
// let's build those only once and re-use them multiple times
static const std::regex regex1(R"some-reg-exp1", std::regex::optimize);
static const std::regex regex2(R"some-reg-exp2", std::regex::optimize);
static const std::regex regex3(R"some-reg-exp3", std::regex::optimize);
string str = "some string to split";
std::vector<std::string> tokens( splitString(str, regex1) );
注意事项：
这是对this answer 的一个小改进 另见Optimization techniques used by std::regex_constants::optimize【讨论】：
这是一个不完整的答案，没有真正做或解释任何事情。【参考方案29】：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 = ++j;
j = s.find(c, j);
if (j >= s.length())
v.push_back(s.substr(i, s,length()));
break;
return v;
【讨论】：
请更准确。您的代码将无法编译。请参阅“i”的声明和逗号而不是点。以上是关于使用字符串分隔符（标准 C++）在 C++ 中解析（拆分）字符串的主要内容，如果未能解决你的问题，请参考以下文章