如何迭代由空格分隔的单词组成的字符串中的单词？
注意，我对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);
}
当前回答
有一种更简单的方法可以做到这一点！！
#include <vector>
#include <string>
std::vector<std::string> splitby(std::string string, char splitter) {
int splits = 0;
std::vector<std::string> result = {};
std::string locresult = "";
for (unsigned int i = 0; i < string.size(); i++) {
if ((char)string.at(i) != splitter) {
locresult += string.at(i);
}
else {
result.push_back(locresult);
locresult = "";
}
}
if (splits == 0) {
result.push_back(locresult);
}
return result;
}
void printvector(std::vector<std::string> v) {
std::cout << '{';
for (unsigned int i = 0; i < v.size(); i++) {
if (i < v.size() - 1) {
std::cout << '"' << v.at(i) << "\",";
}
else {
std::cout << '"' << v.at(i) << "\"";
}
}
std::cout << "}\n";
}
其他回答
LazyString拆分器：
#include <string>
#include <algorithm>
#include <unordered_set>
using namespace std;
class LazyStringSplitter
{
string::const_iterator start, finish;
unordered_set<char> chop;
public:
// Empty Constructor
explicit LazyStringSplitter()
{}
explicit LazyStringSplitter (const string cstr, const string delims)
: start(cstr.begin())
, finish(cstr.end())
, chop(delims.begin(), delims.end())
{}
void operator () (const string cstr, const string delims)
{
chop.insert(delims.begin(), delims.end());
start = cstr.begin();
finish = cstr.end();
}
bool empty() const { return (start >= finish); }
string next()
{
// return empty string
// if ran out of characters
if (empty())
return string("");
auto runner = find_if(start, finish, [&](char c) {
return chop.count(c) == 1;
});
// construct next string
string ret(start, runner);
start = runner + 1;
// Never return empty string
// + tail recursion makes this method efficient
return !ret.empty() ? ret : next();
}
};
我将此方法称为LazyStringSplitter是因为一个原因——它不会一次性拆分字符串。本质上，它的行为类似于python生成器它公开了一个名为next的方法，该方法返回从原始字符串拆分的下一个字符串我使用了c++11STL中的无序集，因此查找分隔符的速度要快得多下面是它的工作原理
测试程序
#include <iostream>
using namespace std;
int main()
{
LazyStringSplitter splitter;
// split at the characters ' ', '!', '.', ','
splitter("This, is a string. And here is another string! Let's test and see how well this does.", " !.,");
while (!splitter.empty())
cout << splitter.next() << endl;
return 0;
}
输出，输出
This
is
a
string
And
here
is
another
string
Let's
test
and
see
how
well
this
does
改进这一点的下一个计划是实施开始和结束方法，以便可以执行以下操作：
vector<string> split_string(splitter.begin(), splitter.end());
虽然有一些答案提供了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';
}
}
（螺栓连杆）
这是我的版本获取了Kev的来源：
#include <string>
#include <vector>
void split(vector<string> &result, string str, char delim ) {
string tmp;
string::iterator i;
result.clear();
for(i = str.begin(); i <= str.end(); ++i) {
if((const char)*i != delim && i != str.end()) {
tmp += *i;
} else {
result.push_back(tmp);
tmp = "";
}
}
}
之后，调用函数并执行以下操作：
vector<string> hosts;
split(hosts, "192.168.1.2,192.168.1.3", ',');
for( size_t i = 0; i < hosts.size(); i++){
cout << "Connecting host : " << hosts.at(i) << "..." << endl;
}
void splitString(string str, char delim, string array[], const int arraySize)
{
int delimPosition, subStrSize, subStrStart = 0;
for (int index = 0; delimPosition != -1; index++)
{
delimPosition = str.find(delim, subStrStart);
subStrSize = delimPosition - subStrStart;
array[index] = str.substr(subStrStart, subStrSize);
subStrStart =+ (delimPosition + 1);
}
}
这是我使用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
