关于解析：使用字符串分隔符(标准C++)解析(拆分)C++中的字符串

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

本问题已经有最佳答案，请猛点这里访问。

我使用C++解析字符串：

1
2
3
4
5
6
7

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

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

可以使用单个字符分隔符进行分析。但是如果我想使用一个字符串作为分隔符呢？

示例：我要拆分：

1	scott>=tiger

用>=作为分隔符，这样我可以得到Scott和Tiger。

相关讨论

您可以使用std::string::find()函数查找字符串分隔符的位置，然后使用std::string::substr()获取令牌。

例子：

1
2
3

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

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

这样就可以轻松地循环获取每个令牌。

完整的例子

1
2
3
4
5
6
7
8
9
10
11

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;

输出：

1
2
3

scott
tiger
mushroom

相关讨论

此方法使用std::string::find，而不通过记住前一个子字符串标记的开始和结束来改变原始字符串。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#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函数拆分字符串：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

相关讨论

strtok允许您以分隔符的形式传入多个字符。我敢打赌，如果您传入">="，您的示例字符串将被正确拆分(即使>和=被算作单个分隔符)。

如果不想使用c_str()将字符串转换为char*，则可以使用substr，并首先找到要标记化的。

1
2
3
4
5
6

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

相关讨论

用于字符串分隔符

基于字符串分隔符拆分字符串。如根据字符串分隔符"-+"拆分字符串"adsf-+qwret-+nvfkbdsj-+orthdfjgh-+dfjrleih"，输出为{"adsf","qwret","nvfkbdsj","orthdfjgh","dfjrleih"}。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

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

产量

1
2
3
4
5

adsf
qwret
nvfkbdsj
orthdfjgh
dfjrleih

对于单字符分隔符

基于字符分隔符拆分字符串。如分隔符为"+"的拆分字符串"adsf+qwer+poui+fdgh"将输出{"adsf","qwer","poui","fdg"h}。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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

产量

1
2
3
4

adsf
qwer
poui
fdgh

相关讨论

这段代码将文本中的行分割开来，并将每个人添加到一个向量中。

1
2
3
4
5
6
7
8
9
10
11
12
13

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

致电：

1 2	vector<string> listFilesMax = split(buffer," ");

相关讨论

我会用boost::tokenizer。以下是解释如何生成适当的标记器函数的文档：http://www.boost.org/doc/libs/1__0/libs/tokenizer/tokenizer function.htm

这里有一个适合你的案子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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

相关讨论

这是我的看法。它处理边缘情况，并使用可选参数从结果中删除空条目。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

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

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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]()

如果您不想修改字符串(如Vincenzo PII的答案中所示)，也不想输出最后一个令牌，那么您可以使用以下方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include<iostream>
#include
using namespace std;

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

void split(string str,char delimit,string res[]){
int a=0,i=0;
while(a<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：仅当拆分后的字符串长度相等时才有效

相关讨论

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

相关讨论