在c++中使用字符串分隔符解析(拆分)字符串(标准c++)

我在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

用>=作为分隔符，这样我就可以得到斯科特和老虎。

1979175 次浏览

小开

strtok允许您传入多个字符作为分隔符。我敢打赌，如果你传入“>=”，你的示例字符串将被正确分割(即使>和=被算作单独的分隔符)。

编辑如果你不想使用c_str()将字符串转换为char*，你可以使用字符串的子串和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());
}

小开

我会使用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';
}

小开

最佳答案

您可以使用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

小开

该方法使用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);
}

小开

你可以使用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;
}

小开

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;
}

小开

如果你不想修改字符串(就像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;
}

小开

以下是我的看法。它处理边缘情况，并接受一个可选参数从结果中删除空条目。

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 != std::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]()

小开

这段代码从文本中分离行，并将每个行添加到一个向量中。

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");

小开

对于字符串分隔符

基于字符串分隔符拆分字符串。例如根据字符串分隔符"-+"分割字符串"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;
}

输出< / >强

adsf qwret nvfkbdsj orthdfjgh 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 < 输出< / >强

adsf qwer poui fdgh

小开

#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; }

注:仅当分割后的字符串长度相等时才有效

小开

这是一个完整的方法，它在任何分隔符上分割字符串，并返回分割后的字符串的向量。

这是改编自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; }

小开

答案已经在那里，但选择答案使用擦除功能，这是非常昂贵的，想想一些非常大的字符串(以mb为单位)。因此我使用下面的函数。

vector<string> split(const string& i_str, const string& i_delim) { vector<string> result; size_t startIndex = 0; for (size_t found = i_str.find(i_delim); found != string::npos; found = i_str.find(i_delim, startIndex)) { result.emplace_back(i_str.begin()+startIndex, i_str.begin()+found); startIndex = found + i_delim.size(); } if (startIndex != i_str.size()) result.emplace_back(i_str.begin()+startIndex, i_str.end()); return result; }

小开

对于字符串(或单个字符)分隔符，这应该非常有效。别忘了加上#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::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; }

小开

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; }

小开

一种非常简单/幼稚的方法:

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);

小开

由于这是Stack Overflow谷歌搜索C++ split string或类似结果的最高评级，我将发布一个完整的、复制/粘贴可运行的示例，展示这两个方法。

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); }

小开

作为奖励，这里有一个分割函数和宏的代码示例，很容易使用，你可以在其中选择容器类型:

#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 < 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) { std::regex regexz(regex_str); return {std::sregex_token_iterator(str.begin(), str.end(), regexz, -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; } }

<一个href = " https://cpp.sh/?source=%23include%20%3Ciostream%3E%0D%0A%23include%20%3Cstring%3E%0D%0A%23include%20%3Cregex%3E%0D%0A%0D%0Astd%3A%3Avector%3Cstd%3A%3Astring%3E%20split (const std % 3 a % % 20 3 astring % 20 str % 2 c % d % 0 a % 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20 const % 20性病% % 3 astring % 20 regex_str 3) % 7 b % d % 0 a % 20% 20% 20% 20% 20 std % 3 a % 3 aregex % 20 regexz (regex_str) % 3 b % d % 0 20% % % 20% 20% 20% 20 7 bstd % 3 a % 3 asregex_token_iterator (str.begin () % 2 c % 20 str.end () % 2 c % 20正则表达式z % 2 c %为20:1)% 2 c % 0 d % 0 a % 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20% 20 std % 3 a % 3 asregex_token_iterator 7 () % d % 3 b % d % 0 a % 7 d % 0 d % 0 a % d % 0不是% 20个主要()% d % 0 0 % 7 b % d % 0 a % 20% 20% 20% 20 std % 3 a % 3 astring % 20 input_str % 20% 3 d % 22让% 20分% 20 20% % 3 b % 0 d % 0 a % 22% 20% 20% 20% 20 std % 3 a % 3 astring % 20 regex_str 3 d % % 20% 20% 22% 20% 22% 3 b % d % 0 20% % 20汽车% 20令牌% 20% 20% 20% 20% 3 d % 20分(input_str % 2 c % 20 regex_str) % 3 b % d % 0 a % 20% 20% 20% 20 % 20(汽车% 26% 20项% % 20令牌3)% d % 0 7 b % 20% 20% 20% 20% % 0 d % 0 a % 20% 20% 20% 20% 20% 20% 20% 20性病% 3 a % 3 acout % 3 c % 3 citem % 20% 3 c % 3 cstd % 3A%3Aendl%3B%0D%0A%20%20%20%20%7D%0D%0A%7D" rel="nofollow noreferrer">玩它在线!< / >

你可以简单地使用子字符串，字符等正常，或使用实际的正则表达式来进行分割。
它也是简洁的c++ 11!

小开

从c++ 11开始，它可以这样做:

std::vector<std::string> splitString(const std::string& str, const std::regex& regex) { return {std::sregex_token_iterator{str.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) );

注:

这是对这个答案的一个小改进

参见std::regex_constants::optimize使用的优化技术

小开

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; }

小开

还有另一个答案:这里我使用find_first_not_of字符串函数，其中返回是第一个字符的位置，不与delim中指定的任何字符匹配。

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

小开

我得到这个解。这很简单，所有的打印/值都在循环中(循环后不需要检查)。

#include <iostream> #include <string> using std::cout; using std::string; int main() { string s = "it-+is-+working!"; string d = "-+"; int firstFindI = 0; int secendFindI = 0; 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 } }

感谢@SteveWard改进了这个答案。

小开

我使用指针算术。对于字符串delim，如果你对char delim满意，只需简单地删除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; }

小开

这是一个简洁的分裂函数。我决定让背靠背分隔符返回为空字符串，但您可以很容易地检查子字符串是否为空，如果是，则不将其添加到向量。

#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; }

小开

用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; } }
:
# EYZ0
# EYZ0 

小开

这与其他答案类似，但它使用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(); }

小开

以防将来有人想要跳出Pii Vincenzo的答案的方框函数

#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; }

我还修复了一些错误，以便如果字符串的开头或结尾有分隔符，函数将不会返回空字符串

小开

一个更简单的解决方案是-
您可以使用strtok在多字符分隔符的基础上进行分隔。记住使用strdup，这样原始字符串就不会发生变化
#include <stdio.h> #include <string.h> const char* str = "scott>=tiger"; char *token = strtok(strdup(str), ">="); while (token != NULL) { printf("%s\n", token); token = strtok(NULL, ">="); }

小开

这个方法使用字符串中找到和字符串的子串

vector<string> split(const string& str,const string delim){ vector<string> vtokens; size_t start = 0; size_t end = 0; while((end = str.find(delim,start))!=string::npos){ vtokens.push_back(str.substr(start,end-start)); start = end +1; } vtokens.push_back(str.substr(start)); return vtokens; }

小开

我查看了答案，没有看到一个基于迭代器的方法可以被送入范围循环，所以我做了一个。

这使用了c++ 17 string_views，所以它不应该分配字符串的副本。

struct StringSplit { struct Iterator { size_t tokenStart_ = 0; size_t tokenEnd_ = 0; std::string str_; std::string_view view_; std::string delimiter_; bool done_ = false; Iterator() { // End iterator. done_ = true; } Iterator(std::string str, std::string delimiter) : str_{std::move(str)}, view_{str_}, delimiter_{ std::move(delimiter)} { tokenEnd_ = view_.find(delimiter_, tokenStart_); } std::string_view operator*() { return view_.substr(tokenStart_, tokenEnd_ - tokenStart_); } Iterator &operator++() { if (tokenEnd_ == std::string::npos) { done_ = true; return *this; } tokenStart_ = tokenEnd_ + delimiter_.size(); tokenEnd_ = view_.find(delimiter_, tokenStart_); return *this; } bool operator!=(Iterator &other) { // We only check if both points to the end. if (done_ && other.done_) { return false; } return true; } }; Iterator beginIter_; StringSplit(std::string str, std::string delim) : beginIter_{std::move(str), std::move(delim)} { } Iterator begin() { return beginIter_; } Iterator end() { return Iterator{}; } };

示例用法如下:

int main() { for (auto token : StringSplit{"<>foo<>bar<><>bar<><>baz<><>", "<>"}) { std::cout << "TOKEN: '" << token << "'" << std::endl; } }

打印:

TOKEN: '' TOKEN: 'foo' TOKEN: 'bar' TOKEN: '' TOKEN: 'bar' TOKEN: '' TOKEN: 'baz' TOKEN: '' TOKEN: ''

它正确地处理字符串开头和结尾的空项。

提交答案