Question

我有一个字符串向量，我想将它输出到流（实际上是文件流）。我希望在矢量元素之间有一个分隔符。有一种方法可以使用标准ostream_iterator

std::vector <std::string> strs;
std::ostream_iterator<std::string> out_file_iterator ( out_file, delim );
std::copy ( strs.begin(), strs.end(), out_file_iterator );

我不喜欢这种方式，因为在每个元素之后有一个delim文本，但我不需要在最后一个元素之后有一个delim。我想使用像boost::join这样的东西。但是boost::join返回字符串而我的向量太大而无法将其输出到字符串。

实现目标的最优雅方式是什么？

Answer 1

一种方法是分别处理最后一种方法。但不要以为它非常优雅。当然，你可以将丑陋包裹在你自己的join函数中。

assert(strs.size() > 0);
std::ostream_iterator<std::string> out_file_iterator ( out_file, delim );
std::copy ( strs.begin(), strs.end()-1, out_file_iterator );
out_file << strs.back();

Answer 2

最优雅的是编写自己的循环。或者单独的功能。

template<class Stream, class InIt>
void print_range(Stream& s, InIt first, InIt last, char const* delim = "\n"){
  if(first == last)
    return;
  s << *first++;
  for(; first != last; ++first){
    s << delim << *first;
  }
}

Answer 3

对于一般解决方案（未经测试）：

template<class T>
class ostream_join_iterator {
public:

    // Construct like an ostream_iterator.
    ostream_join_iterator(std::ostream& stream,
        const std::string& delimiter = "")
        : stream(stream), delimiter(delimiter), first(true) {}

    // Behave like an output iterator.
    ostream_join_iterator& operator++()    { return *this; }
    ostream_join_iterator& operator++(int) { return *this; }
    ostream_join_iterator& operator*()     { return *this; }

    // Output a delimiter before all but the first element.
    template<class T>
    ostream_join_iterator& operator=(const T& value) {
        if (!first) {
            stream << delimiter;
        } else {
            first = false;
        }
        stream << value;
        return *this;
    }

private:

    std::ostream& stream;
    const std::string delimiter;
    bool first;

};

您可以像常规std::ostream_iterator一样使用它：

std::copy(strings.begin(), strings.end(),
    ostream_join_iterator<std::string>(file, delimiter));

Answer 4

这是一个带有仿函数的想法

using namespace std;

struct add_delim_t {
  add_delim_t(const char *_delim) : delim_(_delim), is_first_(true) {}
  string operator () (const string &_val) {
    if (is_first_) { is_first_ = false; return _val; } else return delim_ + _val;
  }
private:
  const string delim_;
  bool is_first_;
};

transform(s.begin(), s.end(), ostream_iterator<string>(cout), add_delim_t(" , "));

此解决方案的问题是它使用statefull谓词。从理论上讲，这意味着UB。

Answer 5

Boost Function Input Iterator有一个想法

using namespace std;

struct generator {
  typedef string result_type;
  generator(result_type _delim) : delim_(_delim), is_first_(true) {}
  result_type operator () () { 
    if (!is_first_)
      return delim_; 
    is_first_ = false; 
    return ""; 
  }
private:
  result_type delim_;
  bool is_first_;
};

template<class T>
struct reverse_plus : public binary_function<T, T, T> {
  T operator()(const T& _lhs, const T& _rhs) const { return (_rhs + _lhs); }
};

// output to file stream
transform
( strs.begin()
, strs.end()
, boost::make_function_input_iterator(generator(" , "), boost::infinite())
, ostream_iterator<string> out_file_iterator(out_file)
, reverse_plus<string>()
);

将字符串向量加入std :: ostream（如boost :: join）

5 个答案: