创建一个粘性操纵器，在输出流的每个标记之间插入分隔符

Question

我已经看到了示例，可以使您创建一个插入定界器的操纵器，但这些操纵器都不粘。也就是说，操纵器返回一个特殊的类，该类别插入定界符，而不是永久修改输出流，以便它可以自己做。

我希望能够做到这一点：

std::cout << sep(", ");
std::cout << "hello" << "world";
// "hello, world"

此刻此打印“ h，e，e，l，l，o，w，o，r，l，l，l，d”当我需要它为“你好，世界” 。我获得错误的输出的原因是因为我将打印量放在溢出（）方法和Overflow（）中。我不确定将其放在哪里。

对不起，它是冗长的。如果我知道一种更简单的写作方法，我会的。只需从底部开始，然后从底部开始工作：

#include <iostream>
#include <cstring>

// index for delimiter
int separator() {
  static int idx = std::ios_base::xalloc();
  return idx;
}

// index for storage of dynamically-allocated buffer
int rdbuffer() {
  static int idx = std::ios_base::xalloc();
  return idx;
}

struct custom_separator : std::streambuf {
 public:
  custom_separator(std::ostream& _stream)
      : stream(_stream), buffer(_stream.rdbuf()) {}

  int_type overflow(int_type c) {
    // has a token been read already
    if (token_read) {
      char* delim = static_cast<char*>(stream.pword(separator()));
      // print delim
      buffer->sputn(delim, strlen(delim));
    }
    token_read = true;
    return buffer->sputc(c);
  }

 private:
  std::ostream& stream;
  std::streambuf* buffer;
  bool token_read = false;
};

// deletes the buffer and the delimiter
void cleanup(std::ios_base::event evt, std::ios_base& str, int idx) {
  if (evt == std::ios_base::erase_event) {
    delete static_cast<const char*>(str.pword(idx));
    delete static_cast<custom_separator*>(str.pword(rdbuffer()));
  }
}

std::ostream& set_separator(std::ostream& os, const char* str) {
  if (!os.bad()) {
    // If a separator string doesn't exist, assign os a buffer that prints one
    if (!os.pword(separator())) {
      auto buf = new custom_separator(os);
      os.rdbuf(buf);
      // this is to keep track of buf so we can delete it later
      os.pword(rdbuffer()) = static_cast<void*>(buf);
      os.register_callback(cleanup, separator());
    }
    // delete the previous separator
    delete static_cast<const char*>(os.pword(separator()));
    // store the new one
    os.pword(separator()) = (void*)(str);
  }
  return os;
}

struct sep {
  explicit sep(const char* _sep) 
    : separator(new char[strlen(_sep) + 1]) {
    strcpy(separator, _sep);
  }
  sep(const sep&) = delete;
  sep(const sep&&) = delete;
  char* separator;
};

std::ostream& operator<<(std::ostream& os, const sep& manip) {
  set_separator(os, manip.separator);
  return os;
}

int main() {
  std::cout << sep(", ");
  std::cout << "hello";
  std::cout << "world";
  // "h, e, l, l, o, w, o, r, l, d"
}

Overflow（）的主要问题是，我不知道什么时候可以检测到令牌的结尾，例如“ Hello” 已被阅读以了解何时插入。

Answer 1

尝试以下操作。此外，还添加了新换行符处理（新行符号），以便在传输过程中（新行之后）不会添加分隔符。

#include <iostream>

class MyStream
{
    public:
        struct Sep
        {
            Sep (const std::string& sep_value = ""):
                m_sep(sep_value)
            {
            }
            
            operator std::string()
            {
                return m_sep;
            }
                
            private:
            std::string m_sep;
        };
        
        MyStream& operator << (const Sep& sep)
        {
            m_sep = sep;
            m_add_sep = false;
            return *this;
        }
        
        MyStream& operator << (const std::string& str)
        {
            if(str.find(MyStream::endl) != std::string::npos)
                m_add_sep = false;
            operator<< <std::string>(str);
            m_add_sep = false;
            return *this;
        }
        
        template <typename T>
        MyStream& operator << (const T& value)
        {
            if(m_add_sep)
                std::cout << static_cast<std::string>(m_sep);
            std::cout << value;
            m_add_sep = true;
            return *this;
        }
        
    static const std::string endl;
        
    private:
        Sep m_sep;
        bool m_add_sep = false;
};

const std::string MyStream::endl = std::string("\n");

int main()
{
    MyStream stream;
    stream << "hello" << "world" << MyStream::endl; // prints "helloworld"
    stream << MyStream::Sep(", ");
    stream << "hello" << "world" << MyStream::endl; // prints "hello, world"
    stream << 1 << 2;
    stream << 3 << MyStream::endl; // both lines prints "1, 2, 3"
    stream << MyStream::Sep();
    stream << 1 << 2 << 3 << MyStream::endl; // prints "123"
    return 0;
}

Answer 2

1. 这是一个可能的解决方案。分离器是所有流的 。

    名称空间alt_std
    {
      结构Sep
      {
        sep（const char* s）{s_ = s; }
   
        朋友STD :: Ostream＆amp;操作员＆lt;＆lt;（std :: ostream＆amp; os，const sep＆amp; sm）
        {
          返回操作系统；
        }
   
        内联静态std :: string s_ {};
      };
   
      STD :: Ostream＆amp;操作员＆lt;＆lt;（std :: ostream＆amp; os，const char* s）
      {
        返回std ::操作员＆lt;＆lt;（OS，s），std ::操作员＆lt;＆lt;（OS，sep :: s_）;
      }
    }
   
    int main（）
    {
      使用名称空间alt_std;
   
      std :: cout＆lt;＆lt; sep（“”）＆lt;＆lt; “你好”;
      std :: cout＆lt;＆lt; “世界”＆lt;＆lt; std :: endl; //“ Hello World \ n”
   
      std :: cout＆lt;＆lt; sep（“”）＆lt;＆lt; “ Hel”＆lt;＆lt; “ LO”； // “你好”
    }
    

2. 如果您想在流对象级别上进行操作，则更困难，因为流对象没有自定义存储空间您可以在其中存储分离器的值。

3. ，或者您可以简单地包装流对象：

    模板＆lt;键入OS＆gt;
    结构包装器
    {
      wrapper（OS＆amp; os，const char* sep）：os_ {os}，sep_ {sep} {} {}
   
      模板＆lt; T＆gt; typename
      朋友包装＆amp;操作员＆lt;＆lt;（包装器＆amp; os，const t＆amp; v）
      {
        os.os_＆lt;＆lt; v＆lt;＆lt; os.sep_;
        返回操作系统；
      }
   
      OS＆amp; OS_;
      std :: string sep_;
    };
   
    int main（）
    {
      包装器OS {std :: Cout，“”};
      OS＆lt;＆lt; “你好”＆lt;＆lt; “世界”;
    }