如何迭代由空格分隔的单词组成的字符串中的单词？
注意，我对C字符串函数或那种字符操作/访问不感兴趣。比起效率，我更喜欢优雅。我当前的解决方案：
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main() {
string s = "Somewhere down the road";
istringstream iss(s);
do {
string subs;
iss >> subs;
cout << "Substring: " << subs << endl;
} while (iss);
}
当前回答
这是另一个解决方案。它结构紧凑，效率合理：
std::vector<std::string> split(const std::string &text, char sep) {
std::vector<std::string> tokens;
std::size_t start = 0, end = 0;
while ((end = text.find(sep, start)) != std::string::npos) {
tokens.push_back(text.substr(start, end - start));
start = end + 1;
}
tokens.push_back(text.substr(start));
return tokens;
}
它可以很容易地模板化以处理字符串分隔符、宽字符串等。
注意，拆分“”会产生一个空字符串，拆分“，”（即sep）会产生两个空字符串。
它还可以轻松扩展以跳过空令牌：
std::vector<std::string> split(const std::string &text, char sep) {
std::vector<std::string> tokens;
std::size_t start = 0, end = 0;
while ((end = text.find(sep, start)) != std::string::npos) {
if (end != start) {
tokens.push_back(text.substr(start, end - start));
}
start = end + 1;
}
if (end != start) {
tokens.push_back(text.substr(start));
}
return tokens;
}
如果需要在多个分隔符处拆分字符串，同时跳过空标记，则可以使用此版本：
std::vector<std::string> split(const std::string& text, const std::string& delims)
{
std::vector<std::string> tokens;
std::size_t start = text.find_first_not_of(delims), end = 0;
while((end = text.find_first_of(delims, start)) != std::string::npos)
{
tokens.push_back(text.substr(start, end - start));
start = text.find_first_not_of(delims, end);
}
if(start != std::string::npos)
tokens.push_back(text.substr(start));
return tokens;
}
其他回答
没有Boost，没有字符串流，只有标准的C库与std:：string和std:：list:C库函数配合使用，便于分析，C++数据类型便于内存管理。
空白被认为是换行符、制表符和空格的任意组合。空白字符集由wschars变量建立。
#include <string>
#include <list>
#include <iostream>
#include <cstring>
using namespace std;
const char *wschars = "\t\n ";
list<string> split(const string &str)
{
const char *cstr = str.c_str();
list<string> out;
while (*cstr) { // while remaining string not empty
size_t toklen;
cstr += strspn(cstr, wschars); // skip leading whitespace
toklen = strcspn(cstr, wschars); // figure out token length
if (toklen) // if we have a token, add to list
out.push_back(string(cstr, toklen));
cstr += toklen; // skip over token
}
// ran out of string; return list
return out;
}
int main(int argc, char **argv)
{
list<string> li = split(argv[1]);
for (list<string>::iterator i = li.begin(); i != li.end(); i++)
cout << "{" << *i << "}" << endl;
return 0;
}
Run:
$ ./split ""
$ ./split "a"
{a}
$ ./split " a "
{a}
$ ./split " a b"
{a}
{b}
$ ./split " a b c"
{a}
{b}
{c}
$ ./split " a b c d "
{a}
{b}
{c}
{d}
split的尾部递归版本（本身分裂为两个函数）。除了将字符串推入列表之外，所有对变量的破坏性操作都消失了！
void split_rec(const char *cstr, list<string> &li)
{
if (*cstr) {
const size_t leadsp = strspn(cstr, wschars);
const size_t toklen = strcspn(cstr + leadsp, wschars);
if (toklen)
li.push_back(string(cstr + leadsp, toklen));
split_rec(cstr + leadsp + toklen, li);
}
}
list<string> split(const string &str)
{
list<string> out;
split_rec(str.c_str(), out);
return out;
}
这里有一个仅使用标准正则表达式库的正则表达式解决方案。（我有点生疏，所以可能会有一些语法错误，但这至少是一般的想法）
#include <regex.h>
#include <string.h>
#include <vector.h>
using namespace std;
vector<string> split(string s){
regex r ("\\w+"); //regex matches whole words, (greedy, so no fragment words)
regex_iterator<string::iterator> rit ( s.begin(), s.end(), r );
regex_iterator<string::iterator> rend; //iterators to iterate thru words
vector<string> result<regex_iterator>(rit, rend);
return result; //iterates through the matches to fill the vector
}
没有任何内存分配的C++17版本（std:：函数除外）
void iter_words(const std::string_view& input, const std::function<void(std::string_view)>& process_word) {
auto itr = input.begin();
auto consume_whitespace = [&]() {
for(; itr != input.end(); ++itr) {
if(!isspace(*itr))
return;
}
};
auto consume_letters = [&]() {
for(; itr != input.end(); ++itr) {
if(isspace(*itr))
return;
}
};
while(true) {
consume_whitespace();
if(itr == input.end())
return;
auto word_start = itr - input.begin();
consume_letters();
auto word_end = itr - input.begin();
process_word(input.substr(word_start, word_end - word_start));
}
}
int main() {
iter_words("foo bar", [](std::string_view sv) {
std::cout << "Got word: " << sv << '\n';
});
return 0;
}
虽然有一些答案提供了C++20解决方案，但自从发布以来，已经做了一些更改，并将其作为缺陷报告应用于C++20。正因为如此，解决方案变得更短、更好：
#include <iostream>
#include <ranges>
#include <string_view>
namespace views = std::views;
using str = std::string_view;
constexpr str text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
auto splitByWords(str input) {
return input
| views::split(' ')
| views::transform([](auto &&r) -> str {
return {r.begin(), r.end()};
});
}
auto main() -> int {
for (str &&word : splitByWords(text)) {
std::cout << word << '\n';
}
}
到今天为止，它仍然只在GCC的主干分支（Godbolt链接）上可用。它基于两个更改：P1391迭代器构造函数用于std:：string_view和P2210 DR修复std:：views:：split以保留范围类型。
在C++23中，不需要任何转换样板，因为P1989向std:：string_view:添加了一个范围构造函数
#include <iostream>
#include <ranges>
#include <string_view>
namespace views = std::views;
constexpr std::string_view text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
auto main() -> int {
for (std::string_view&& word : text | views::split(' ')) {
std::cout << word << '\n';
}
}
（螺栓连杆）
到目前为止，我在Boost中使用了这个，但我需要一些不依赖它的东西，所以我得出了这个结论：
static void Split(std::vector<std::string>& lst, const std::string& input, const std::string& separators, bool remove_empty = true)
{
std::ostringstream word;
for (size_t n = 0; n < input.size(); ++n)
{
if (std::string::npos == separators.find(input[n]))
word << input[n];
else
{
if (!word.str().empty() || !remove_empty)
lst.push_back(word.str());
word.str("");
}
}
if (!word.str().empty() || !remove_empty)
lst.push_back(word.str());
}
好的一点是，在分隔符中可以传递多个字符。
