如何迭代由空格分隔的单词组成的字符串中的单词？
注意，我对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);
}
当前回答
没有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;
}
其他回答
对于那个些需要使用字符串分隔符拆分字符串的人，也许可以尝试我的以下解决方案。
std::vector<size_t> str_pos(const std::string &search, const std::string &target)
{
std::vector<size_t> founds;
if(!search.empty())
{
size_t start_pos = 0;
while (true)
{
size_t found_pos = target.find(search, start_pos);
if(found_pos != std::string::npos)
{
size_t found = found_pos;
founds.push_back(found);
start_pos = (found_pos + 1);
}
else
{
break;
}
}
}
return founds;
}
std::string str_sub_index(size_t begin_index, size_t end_index, const std::string &target)
{
std::string sub;
size_t size = target.length();
const char* copy = target.c_str();
for(size_t i = begin_index; i <= end_index; i++)
{
if(i >= size)
{
break;
}
else
{
char c = copy[i];
sub += c;
}
}
return sub;
}
std::vector<std::string> str_split(const std::string &delimiter, const std::string &target)
{
std::vector<std::string> splits;
if(!delimiter.empty())
{
std::vector<size_t> founds = str_pos(delimiter, target);
size_t founds_size = founds.size();
if(founds_size > 0)
{
size_t search_len = delimiter.length();
size_t begin_index = 0;
for(int i = 0; i <= founds_size; i++)
{
std::string sub;
if(i != founds_size)
{
size_t pos = founds.at(i);
sub = str_sub_index(begin_index, pos - 1, target);
begin_index = (pos + search_len);
}
else
{
sub = str_sub_index(begin_index, (target.length() - 1), target);
}
splits.push_back(sub);
}
}
}
return splits;
}
这些片段由3个函数组成。坏消息是使用str_split函数，您将需要另外两个函数。是的，这是一大块代码。但好消息是，这两个附加功能可以独立工作，有时也很有用
测试main（）块中的函数如下：
int main()
{
std::string s = "Hello, world! We need to make the world a better place. Because your world is also my world, and our children's world.";
std::vector<std::string> split = str_split("world", s);
for(int i = 0; i < split.size(); i++)
{
std::cout << split[i] << std::endl;
}
}
它将产生：
Hello,
! We need to make the
a better place. Because your
is also my
, and our children's
.
我认为这不是最有效的代码，但至少它可以工作。希望有帮助。
这是我解决这个问题的方法：
vector<string> get_tokens(string str) {
vector<string> dt;
stringstream ss;
string tmp;
ss << str;
for (size_t i; !ss.eof(); ++i) {
ss >> tmp;
dt.push_back(tmp);
}
return dt;
}
此函数返回字符串向量。
我使用以下代码：
namespace Core
{
typedef std::wstring String;
void SplitString(const Core::String& input, const Core::String& splitter, std::list<Core::String>& output)
{
if (splitter.empty())
{
throw std::invalid_argument(); // for example
}
std::list<Core::String> lines;
Core::String::size_type offset = 0;
for (;;)
{
Core::String::size_type splitterPos = input.find(splitter, offset);
if (splitterPos != Core::String::npos)
{
lines.push_back(input.substr(offset, splitterPos - offset));
offset = splitterPos + splitter.size();
}
else
{
lines.push_back(input.substr(offset));
break;
}
}
lines.swap(output);
}
}
// gtest:
class SplitStringTest: public testing::Test
{
};
TEST_F(SplitStringTest, EmptyStringAndSplitter)
{
std::list<Core::String> result;
ASSERT_ANY_THROW(Core::SplitString(Core::String(), Core::String(), result));
}
TEST_F(SplitStringTest, NonEmptyStringAndEmptySplitter)
{
std::list<Core::String> result;
ASSERT_ANY_THROW(Core::SplitString(L"xy", Core::String(), result));
}
TEST_F(SplitStringTest, EmptyStringAndNonEmptySplitter)
{
std::list<Core::String> result;
Core::SplitString(Core::String(), Core::String(L","), result);
ASSERT_EQ(1, result.size());
ASSERT_EQ(Core::String(), *result.begin());
}
TEST_F(SplitStringTest, OneCharSplitter)
{
std::list<Core::String> result;
Core::SplitString(L"x,y", L",", result);
ASSERT_EQ(2, result.size());
ASSERT_EQ(L"x", *result.begin());
ASSERT_EQ(L"y", *result.rbegin());
Core::SplitString(L",xy", L",", result);
ASSERT_EQ(2, result.size());
ASSERT_EQ(Core::String(), *result.begin());
ASSERT_EQ(L"xy", *result.rbegin());
Core::SplitString(L"xy,", L",", result);
ASSERT_EQ(2, result.size());
ASSERT_EQ(L"xy", *result.begin());
ASSERT_EQ(Core::String(), *result.rbegin());
}
TEST_F(SplitStringTest, TwoCharsSplitter)
{
std::list<Core::String> result;
Core::SplitString(L"x,.y,z", L",.", result);
ASSERT_EQ(2, result.size());
ASSERT_EQ(L"x", *result.begin());
ASSERT_EQ(L"y,z", *result.rbegin());
Core::SplitString(L"x,,y,z", L",,", result);
ASSERT_EQ(2, result.size());
ASSERT_EQ(L"x", *result.begin());
ASSERT_EQ(L"y,z", *result.rbegin());
}
TEST_F(SplitStringTest, RecursiveSplitter)
{
std::list<Core::String> result;
Core::SplitString(L",,,", L",,", result);
ASSERT_EQ(2, result.size());
ASSERT_EQ(Core::String(), *result.begin());
ASSERT_EQ(L",", *result.rbegin());
Core::SplitString(L",.,.,", L",.,", result);
ASSERT_EQ(2, result.size());
ASSERT_EQ(Core::String(), *result.begin());
ASSERT_EQ(L".,", *result.rbegin());
Core::SplitString(L"x,.,.,y", L",.,", result);
ASSERT_EQ(2, result.size());
ASSERT_EQ(L"x", *result.begin());
ASSERT_EQ(L".,y", *result.rbegin());
Core::SplitString(L",.,,.,", L",.,", result);
ASSERT_EQ(3, result.size());
ASSERT_EQ(Core::String(), *result.begin());
ASSERT_EQ(Core::String(), *(++result.begin()));
ASSERT_EQ(Core::String(), *result.rbegin());
}
TEST_F(SplitStringTest, NullTerminators)
{
std::list<Core::String> result;
Core::SplitString(L"xy", Core::String(L"\0", 1), result);
ASSERT_EQ(1, result.size());
ASSERT_EQ(L"xy", *result.begin());
Core::SplitString(Core::String(L"x\0y", 3), Core::String(L"\0", 1), result);
ASSERT_EQ(2, result.size());
ASSERT_EQ(L"x", *result.begin());
ASSERT_EQ(L"y", *result.rbegin());
}
使用Boost的可能解决方案可能是：
#include <boost/algorithm/string.hpp>
std::vector<std::string> strs;
boost::split(strs, "string to split", boost::is_any_of("\t "));
这种方法可能比字符串流方法更快。由于这是一个通用模板函数，因此可以使用各种分隔符拆分其他类型的字符串（wchar等或UTF-8）。
有关详细信息，请参阅文档。
我对string和u32string~的一般实现，使用boost:：algorithm：：split签名。
template<typename CharT, typename UnaryPredicate>
void split(std::vector<std::basic_string<CharT>>& split_result,
const std::basic_string<CharT>& s,
UnaryPredicate predicate)
{
using ST = std::basic_string<CharT>;
using std::swap;
std::vector<ST> tmp_result;
auto iter = s.cbegin(),
end_iter = s.cend();
while (true)
{
/**
* edge case: empty str -> push an empty str and exit.
*/
auto find_iter = find_if(iter, end_iter, predicate);
tmp_result.emplace_back(iter, find_iter);
if (find_iter == end_iter) { break; }
iter = ++find_iter;
}
swap(tmp_result, split_result);
}
template<typename CharT>
void split(std::vector<std::basic_string<CharT>>& split_result,
const std::basic_string<CharT>& s,
const std::basic_string<CharT>& char_candidate)
{
std::unordered_set<CharT> candidate_set(char_candidate.cbegin(),
char_candidate.cend());
auto predicate = [&candidate_set](const CharT& c) {
return candidate_set.count(c) > 0U;
};
return split(split_result, s, predicate);
}
template<typename CharT>
void split(std::vector<std::basic_string<CharT>>& split_result,
const std::basic_string<CharT>& s,
const CharT* literals)
{
return split(split_result, s, std::basic_string<CharT>(literals));
}
