我们可以在 c++ 中拆分、操作和重新连接字符串吗？在一份声明中？

Question

这是一个有点愚蠢的问题，但出于好奇，是否有可能用 C++ 在一个语句中用逗号分割字符串，对字符串执行一个函数，然后用逗号重新连接它？

这就是我到目前为止所拥有的：

string dostuff(const string& a) {
  return string("Foo");
}

int main() {
  string s("a,b,c,d,e,f");

  vector<string> foobar(100);
  transform(boost::make_token_iterator<string>(s.begin(), s.end(), boost::char_separator<char>(",")),
            boost::make_token_iterator<string>(s.end(), s.end(), boost::char_separator<char>(",")),
            foobar.begin(),
            boost::bind(&dostuff, _1));
  string result = boost::algorithm::join(foobar, ",");
}

所以这将导致将 "a,b,c,d,e,f" 变成 "Foo,Foo,Foo,Foo,Foo,Foo “

我意识到这是 OTT，但只是想扩展我的加速魔法。

Answer 1

首先，请注意您的程序写入“Foo,Foo,Foo,Foo,Foo,Foo,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, ,,,,,,,,,,,,,”到你的结果字符串 - 正如评论中已经提到的，你想在那里使用 back_inserter 。

至于答案，每当某个范围产生单个值时，我都会查看 std::accumulate（因为这是折叠/减少的 C++ 版本）

#include <string>
#include <iostream>
#include <numeric>
#include <boost/tokenizer.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/bind.hpp>
std::string dostuff(const std::string& a) {
  return std::string("Foo");
}
int main() {
  std::string s("a,b,c,d,e,f");
  std::string result =
    accumulate(
     ++boost::make_token_iterator<std::string>(s.begin(), s.end(), boost::char_separator<char>(",")),
       boost::make_token_iterator<std::string>(s.end(), s.end(), boost::char_separator<char>(",")),
       dostuff(*boost::make_token_iterator<std::string>(s.begin(), s.end(), boost::char_separator<char>(","))),
       boost::bind(std::plus<std::string>(), _1,
         bind(std::plus<std::string>(), ",",
            bind(dostuff, _2)))); // or lambda, for slightly better readability
  std::cout << result << '\n';
}

除了现在它远远超过顶部并重复 make_token_iterator 两次。我猜 boost.range 获胜。

Answer 2

void dostuff(string& a) {
    a = "Foo";
}

int main()
{
    string s("a,b,c,d,e,f");
    vector<string> tmp;
    s = boost::join(
          (
            boost::for_each(
              boost::split(tmp, s, boost::is_any_of(",")),
              dostuff
            ),
            tmp
          ),
          ","
        );

    return 0;
}

不幸的是，我无法避免两次提及tmp。也许我稍后会想到一些事情。

Answer 3

我实际上正在开发一个库，允许以比单独迭代器更可读的方式编写代码...不过不知道我是否会完成该项目，似乎死项目往往会在我的计算机上累积...

无论如何我在这里的主要责备显然是迭代器的使用。我倾向于将迭代器视为低级实现细节，在编码时您很少想使用它们。

因此，假设我们有一个合适的库：

struct DoStuff { std::string operator()(std::string const&); };

int main(int argc, char* argv[])
{
  std::string const reference = "a,b,c,d,e,f";

  std::string const result = boost::join(
    view::transform(
      view::split(reference, ","),
      DoStuff()
    ),
    ","
  );
}

视图的想法是成为另一个容器周围的轻包装器：

• 从用户的角度来看，它的行为就像一个容器（减去实际修改容器结构的操作
• ）从角度来看，它是一个轻量级对象，包含尽可能少的数据 -->这里的值是短暂的，并且只在迭代器存在时存在。

我已经让 transform 部分正常工作，我想知道 split 是如何工作的（一般来说），但我想我会进入它;)

Answer 4

好吧，我想这是可能的，但是请不要在生产代码中这样做。

更好的是像这样的东西，

std::string MakeCommaEdFoo(std::string input)
{
    std::size_t commas = std::count_if(input.begin(), input.end(),
        std::bind2nd(std::equal_to<char>(), ','));
    std::string output("foo");
    output.reserve((commas+1)*4-1);
    for(std::size_t idx = 1; idx < commas; ++idx)
        output.append(",foo");
    return output;
}

它不仅性能更好，而且下一个人更容易阅读和理解。