如何迭代由空格分隔的单词组成的字符串中的单词？
注意，我对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);
}
当前回答
我有两条线来解决这个问题：
char sep = ' ';
std::string s="1 This is an example";
for(size_t p=0, q=0; p!=s.npos; p=q)
std::cout << s.substr(p+(p!=0), (q=s.find(sep, p+1))-p-(p!=0)) << std::endl;
然后你可以把它放到一个向量中，而不是打印。
其他回答
对于那些不愿意为代码大小牺牲所有效率并将“高效”视为一种优雅的人来说，以下内容应该是一个最佳选择（我认为模板容器类是一个非常优雅的添加）：
template < class ContainerT >
void tokenize(const std::string& str, ContainerT& tokens,
const std::string& delimiters = " ", bool trimEmpty = false)
{
std::string::size_type pos, lastPos = 0, length = str.length();
using value_type = typename ContainerT::value_type;
using size_type = typename ContainerT::size_type;
while(lastPos < length + 1)
{
pos = str.find_first_of(delimiters, lastPos);
if(pos == std::string::npos)
{
pos = length;
}
if(pos != lastPos || !trimEmpty)
tokens.push_back(value_type(str.data()+lastPos,
(size_type)pos-lastPos ));
lastPos = pos + 1;
}
}
我通常选择使用std:：vector<std:：string>类型作为第二个参数（ContainerT）。。。但在不需要直接访问的情况下，list<>比vector<>快得多，而且您甚至可以创建自己的字符串类，并使用std:：list<subString>之类的方法，其中subString不进行任何复制，从而提高了惊人的速度。
它的速度是这个页面上最快的tokenize的两倍多，几乎是其他页面的5倍。此外，使用完美的参数类型，您可以消除所有字符串和列表副本，以提高速度。
此外，它不执行结果的返回（效率极低），而是将令牌作为引用传递，因此也允许您根据需要使用多个调用来构建令牌。
最后，它允许您指定是否通过最后一个可选参数从结果中删除空标记。
它只需要std:：string。。。其余的是可选的。它不使用流或boost库，但足够灵活，能够自然地接受这些外来类型。
我编写了以下代码。您可以指定分隔符，它可以是字符串。结果类似于Java的String.split，结果中包含空字符串。
例如，如果我们调用split（“ABCPICKABCANYABCTWO:ABC”，“ABC”），结果如下：
0 <len:0>
1 PICK <len:4>
2 ANY <len:3>
3 TWO: <len:4>
4 <len:0>
代码：
vector <string> split(const string& str, const string& delimiter = " ") {
vector <string> tokens;
string::size_type lastPos = 0;
string::size_type pos = str.find(delimiter, lastPos);
while (string::npos != pos) {
// Found a token, add it to the vector.
cout << str.substr(lastPos, pos - lastPos) << endl;
tokens.push_back(str.substr(lastPos, pos - lastPos));
lastPos = pos + delimiter.size();
pos = str.find(delimiter, lastPos);
}
tokens.push_back(str.substr(lastPos, str.size() - lastPos));
return tokens;
}
还有另一种方式——连续传递方式、零分配、基于函数的分隔。
void split( auto&& data, auto&& splitter, auto&& operation ) {
using std::begin; using std::end;
auto prev = begin(data);
while (prev != end(data) ) {
auto&&[prev,next] = splitter( prev, end(data) );
operation(prev,next);
prev = next;
}
}
现在我们可以基于此编写特定的拆分函数。
auto anyOfSplitter(auto delimiters) {
return [delimiters](auto begin, auto end) {
while( begin != end && 0 == std::string_view(begin, end).find_first_of(delimiters) ) {
++begin;
}
auto view = std::string_view(begin, end);
auto next = view.find_first_of(delimiters);
if (next != view.npos)
return std::make_pair( begin, begin + next );
else
return std::make_pair( begin, end );
};
}
我们现在可以生成一个传统的std字符串分割，如下所示：
template<class C>
auto traditional_any_of_split( std::string_view<C> str, std::string_view<C> delim ) {
std::vector<std::basic_string<C>> retval;
split( str, anyOfSplitter(delim), [&](auto s, auto f) {
retval.emplace_back(s,f);
});
return retval;
}
或者我们可以改用find
auto findSplitter(auto delimiter) {
return [delimiter](auto begin, auto end) {
while( begin != end && 0 == std::string_view(begin, end).find(delimiter) ) {
begin += delimiter.size();
}
auto view = std::string_view(begin, end);
auto next = view.find(delimiter);
if (next != view.npos)
return std::make_pair( begin, begin + next );
else
return std::make_pair( begin, end );
};
}
template<class C>
auto traditional_find_split( std::string_view<C> str, std::string_view<C> delim ) {
std::vector<std::basic_string<C>> retval;
split( str, findSplitter(delim), [&](auto s, auto f) {
retval.emplace_back(s,f);
});
return retval;
}
通过更换分流器部分。
这两者都分配了一个返回值缓冲区。我们可以以手动管理生命周期为代价将返回值交换到字符串视图。
我们还可以采用一个延续，一次传递一个字符串视图，甚至避免分配视图向量。
这可以通过一个中止选项进行扩展，这样我们可以在读取几个前缀字符串后中止。
STL还没有这样的方法。
但是，您可以通过使用std:：string:：C_str（）成员来使用C的strtok（）函数，也可以编写自己的函数。下面是我在快速谷歌搜索（“STL字符串分割”）后找到的代码示例：
void Tokenize(const string& str,
vector<string>& tokens,
const string& delimiters = " ")
{
// Skip delimiters at beginning.
string::size_type lastPos = str.find_first_not_of(delimiters, 0);
// Find first "non-delimiter".
string::size_type pos = str.find_first_of(delimiters, lastPos);
while (string::npos != pos || string::npos != lastPos)
{
// Found a token, add it to the vector.
tokens.push_back(str.substr(lastPos, pos - lastPos));
// Skip delimiters. Note the "not_of"
lastPos = str.find_first_not_of(delimiters, pos);
// Find next "non-delimiter"
pos = str.find_first_of(delimiters, lastPos);
}
}
摘自：http://oopweb.com/CPP/Documents/CPPHOWTO/Volume/C++编程-HOWTO-7.html
如果您对代码示例有疑问，请留下评论，我会解释。
仅仅因为它没有实现称为迭代器的typedef或重载<<运算符，并不意味着它是错误的代码。我经常使用C函数。例如，printf和scanf都比std:：cin和std:：cout快（很明显），fopen语法对二进制类型更友好，它们也倾向于生成更小的EXE。
不要被这种“优雅胜过性能”的交易所吸引。
这是另一个解决方案。它结构紧凑，效率合理：
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;
}
