C++ boost:algorithm:：join（）是否可以在一个浮点数容器中运行？

Boost join可用于连接字符串容器（可选地由分隔符字符串分隔），如本例所示：

我的STL技能很弱。我想知道是否有任何方法可以对数字容器（float、double、int）使用相同的函数？似乎应该有一两个班轮来适应其他类型

还有stl的复制功能，这里有一个很好的例子：

---

但我不喜欢它在每个元素后添加分隔符字符串的方式。我只想使用boost。

当然，您可以组合

boost:：algorithm:：join

并将双精度转换为字符串，然后将它们连接在一起

#include <iostream>
#include <vector>
#include <string>

#include <boost/algorithm/string/join.hpp>
#include <boost/range/adaptor/transformed.hpp>

int main()
{
    using boost::adaptors::transformed;
    using boost::algorithm::join;

    std::vector<double> v{1.1, 2.2, 3.3, 4.4};

    std::cout 
      << join( v | 
               transformed( static_cast<std::string(*)(double)>(std::to_string) ), 
               ", " );
}

我的STL技能很弱。我想知道，对于数字容器（float、double、int）是否也可以使用相同的函数？似乎应该有一个或两个班轮来适应其他类型

std:：accumulate

允许使用二进制函数对任何（输入）迭代器范围进行折叠，该函数可以对“累加器”和下一项采用不同的类型。在您的例子中：一个函数，它使用一个

std:：string

和一个

double

（或其他）将给定的

std:：string

与第二个参数上的

std:：to_string

的结果连接起来

template<typename Container>
std::string contents_as_string(Container const & c,
                               std::string const & separator) {
  if (c.size() == 0) return "";
  auto fold_operation = [&separator] (std::string const & accum,
                                      auto const & item) {
    return accum + separator + std::to_string(item);};
  return std::accumulate(std::next(std::begin(c)), std::end(c),
                         std::to_string(*std::begin(c)), fold_operation);
}

0.100000、1.100000、2.100000、3.100000
1x2x3x4x5=120

---

“|”符号是什么意思？它是XOR，我知道，但我不明白它如何与“vector | transformed（[]）”一起使用：？？我试着用boost 1.47和gcc 4.6.3编译它-我有很多错误…@Alexanderkach它不是XOR，它是按位或用于内置（

int

s等等）。在这种情况下，它是一个重载运算符，请搜索

运算符|

。您可以阅读第一个参数

SinglePassRange

的要求。类似

vector

的stdlib容器满足这些要求。上面的代码将参数应用于

变换
向量的每个元素h、 这真是一个有趣的功能！我对它不太熟悉。我要去看它..谢谢（而且很抱歉，这是一个打字错误-一个意思，当然是：）
template<typename Container>
std::string contents_as_string(Container const & c,
                               std::string const & separator) {
  if (c.size() == 0) return "";
  auto fold_operation = [&separator] (std::string const & accum,
                                      auto const & item) {
    return accum + separator + std::to_string(item);};
  return std::accumulate(std::next(std::begin(c)), std::end(c),
                         std::to_string(*std::begin(c)), fold_operation);
}

int main() {
  std::vector<double> v(4);
  std::iota(std::begin(v), std::end(v), 0.1);
  std::cout << contents_as_string(v, ", ") << std::endl;

  std::vector<int> w(5);
  std::iota(std::begin(w), std::end(w), 1);
  std::cout << contents_as_string(w, " x ") << " = "
    << std::accumulate(std::begin(w), std::end(w), 1, std::multiplies<int>{})
    << std::endl;
}