如何迭代由空格分隔的单词组成的字符串中的单词？
注意，我对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);
}
当前回答
根据Galik的回答，我做了这个。这大部分都在这里，所以我不必一遍又一遍地写。C++仍然没有原生拆分函数，这真是太疯狂了。特征：
应该很快。容易理解（我认为）。合并空节。使用多个分隔符（例如“\r\n”）很简单
#include <string>
#include <vector>
#include <algorithm>
std::vector<std::string> split(const std::string& s, const std::string& delims)
{
using namespace std;
vector<string> v;
// Start of an element.
size_t elemStart = 0;
// We start searching from the end of the previous element, which
// initially is the start of the string.
size_t elemEnd = 0;
// Find the first non-delim, i.e. the start of an element, after the end of the previous element.
while((elemStart = s.find_first_not_of(delims, elemEnd)) != string::npos)
{
// Find the first delem, i.e. the end of the element (or if this fails it is the end of the string).
elemEnd = s.find_first_of(delims, elemStart);
// Add it.
v.emplace_back(s, elemStart, elemEnd == string::npos ? string::npos : elemEnd - elemStart);
}
// When there are no more non-spaces, we are done.
return v;
}
其他回答
我知道很晚才来参加聚会，但我正在考虑最优雅的方法，如果给你一系列分隔符而不是空格，并且只使用标准库。
以下是我的想法：
要通过分隔符序列将单词拆分为字符串向量，请执行以下操作：
template<class Container>
std::vector<std::string> split_by_delimiters(const std::string& input, const Container& delimiters)
{
std::vector<std::string> result;
for (auto current = begin(input) ; current != end(input) ; )
{
auto first = find_if(current, end(input), not_in(delimiters));
if (first == end(input)) break;
auto last = find_if(first, end(input), is_in(delimiters));
result.emplace_back(first, last);
current = last;
}
return result;
}
通过提供一系列有效字符，以另一种方式进行拆分：
template<class Container>
std::vector<std::string> split_by_valid_chars(const std::string& input, const Container& valid_chars)
{
std::vector<std::string> result;
for (auto current = begin(input) ; current != end(input) ; )
{
auto first = find_if(current, end(input), is_in(valid_chars));
if (first == end(input)) break;
auto last = find_if(first, end(input), not_in(valid_chars));
result.emplace_back(first, last);
current = last;
}
return result;
}
is_in和not_in的定义如下：
namespace detail {
template<class Container>
struct is_in {
is_in(const Container& charset)
: _charset(charset)
{}
bool operator()(char c) const
{
return find(begin(_charset), end(_charset), c) != end(_charset);
}
const Container& _charset;
};
template<class Container>
struct not_in {
not_in(const Container& charset)
: _charset(charset)
{}
bool operator()(char c) const
{
return find(begin(_charset), end(_charset), c) == end(_charset);
}
const Container& _charset;
};
}
template<class Container>
detail::not_in<Container> not_in(const Container& c)
{
return detail::not_in<Container>(c);
}
template<class Container>
detail::is_in<Container> is_in(const Container& c)
{
return detail::is_in<Container>(c);
}
这是我最喜欢的遍历字符串的方法。每个词你都可以做你想做的事。
string line = "a line of text to iterate through";
string word;
istringstream iss(line, istringstream::in);
while( iss >> word )
{
// Do something on `word` here...
}
仅为方便：
template<class V, typename T>
bool in(const V &v, const T &el) {
return std::find(v.begin(), v.end(), el) != v.end();
}
基于多个分隔符的实际拆分：
std::vector<std::string> split(const std::string &s,
const std::vector<char> &delims) {
std::vector<std::string> res;
auto stuff = [&delims](char c) { return !in(delims, c); };
auto space = [&delims](char c) { return in(delims, c); };
auto first = std::find_if(s.begin(), s.end(), stuff);
while (first != s.end()) {
auto last = std::find_if(first, s.end(), space);
res.push_back(std::string(first, last));
first = std::find_if(last + 1, s.end(), stuff);
}
return res;
}
用法：
int main() {
std::string s = " aaa, bb cc ";
for (auto el: split(s, {' ', ','}))
std::cout << el << std::endl;
return 0;
}
这是我的条目：
template <typename Container, typename InputIter, typename ForwardIter>
Container
split(InputIter first, InputIter last,
ForwardIter s_first, ForwardIter s_last)
{
Container output;
while (true) {
auto pos = std::find_first_of(first, last, s_first, s_last);
output.emplace_back(first, pos);
if (pos == last) {
break;
}
first = ++pos;
}
return output;
}
template <typename Output = std::vector<std::string>,
typename Input = std::string,
typename Delims = std::string>
Output
split(const Input& input, const Delims& delims = " ")
{
using std::cbegin;
using std::cend;
return split<Output>(cbegin(input), cend(input),
cbegin(delims), cend(delims));
}
auto vec = split("Mary had a little lamb");
第一个定义是采用两对迭代器的STL样式泛型函数。第二个是一个方便的函数，可以让你不用自己做所有的开始和结束。例如，如果要使用列表，还可以将输出容器类型指定为模板参数。
它之所以优雅（IMO），是因为与其他大多数答案不同，它不限于字符串，而是可以与任何STL兼容的容器一起使用。在不更改上述代码的情况下，您可以说：
using vec_of_vecs_t = std::vector<std::vector<int>>;
std::vector<int> v{1, 2, 0, 3, 4, 5, 0, 7, 8, 0, 9};
auto r = split<vec_of_vecs_t>(v, std::initializer_list<int>{0, 2});
这将在每次遇到0或2时将向量v分割成单独的向量。
（还有一个额外的好处，即使用字符串，这个实现比基于strtok（）和getline（）的版本更快，至少在我的系统上是这样。）
这是我使用C++11和STL的解决方案。它应该是合理有效的：
#include <vector>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <functional>
std::vector<std::string> split(const std::string& s)
{
std::vector<std::string> v;
const auto end = s.end();
auto to = s.begin();
decltype(to) from;
while((from = std::find_if(to, end,
[](char c){ return !std::isspace(c); })) != end)
{
to = std::find_if(from, end, [](char c){ return std::isspace(c); });
v.emplace_back(from, to);
}
return v;
}
int main()
{
std::string s = "this is the string to split";
auto v = split(s);
for(auto&& s: v)
std::cout << s << '\n';
}
输出：
this
is
the
string
to
split
