如何一次性运行多个运算符<<

Question

我已经实现了一个自定义记录器，我将信息转储到相应的文件：

像这样：

Logger::log["log_file"] << "Hi" << "Hi again" << "\n";

operator << 的实现如下。请注意缓冲区达到限制时转储到流中的位置：

//This is the function signature of std::endl and some other manipulators
typedef CoutType& (*StandardEndLine)(CoutType&);
/// This method defines an operator<< to take in std::endl
BasicLogger& operator<<(StandardEndLine manip);
/// write the log items to buffer
template <typename T>
BasicLogger & operator<< (const T& val)
{
    std::stringstream *out = BasicLogger::getOut();
    *out << val;
    if(out->tellp() > 512000/*500KB*/){
        flushLog();
    }
    return *this;
}

我的问题在于有多个 <<s 的行：

Logger::log["log_file"] << "Hi" << "Hi again" << "\n";

在执行<< "Hi" 之后，缓冲区可能会变满并执行刷新到流。 这对我来说是不可取的。 如果一行还没有结束，我正在寻找一种解决方案来忽略该限制（500KB）。

示例场景： 当应用程序将由不同线程填充的缓冲区写入同一个文件时，这个问题会突出显示：第一个缓冲区的最后一行写了一半，当另一个线程的第二个缓冲区在我可以完成最后一行之前将另外 500kb 写入文件时第一个缓冲区。

感谢您的想法和解决方案。 谢谢

Answer 1

将多个<< 分组为单个刷新的传统解决方案是使用在语句末尾销毁的临时哨兵对象。

析构函数会刷新（如果需要），如果你想要的话，你甚至可以让它自动附加一个换行符。根据 Andrew Medico 的评论，如果您需要同步，哨兵 ctor/dtor 也应该锁定/解锁。

另一种方法是将所有内容收集到哨兵的本地 ostringstream 中，然后您只需从 dtor 锁定/写入/刷新/解锁单个字符串。

详情：

1. 您的 Logger::log["log_file"] 运算符应返回一个临时对象，该对象具有您从上述选项中选择的行为
2. 您的各种 << 是操作员调​​用，将其作为第一个参数，并返回对您的哨兵类型的引用
3. 在;，临时哨兵超出范围并在其析构函数中执行任何刷新工作。

请注意，如果您只是委托给现有的 ostream，您可以轻松地拥有一个模板化的 Logger::sentry& operator<< (Logger::sentry&, T)。

---

编辑：我以为我以前做过：问题不是重复的，但答案是重复的。 https://stackoverflow.com/a/19520409/212858

Answer 2

我正在寻找一种解决方案来忽略该限制（500KB）如果一行还没有结束。

为什么不在刷新日志之前检查最后一个字符是 '\n' 呢？
如果我知道 T 中的内容，我会给你举个例子。如果它是一个 c++11 字符串，你可以这样做：

char ch = val.getString().back();
if(out->tellp() > 512000/*500KB*/  && ch == '\n'){
   flushLog();
}

Answer 3

只需标记一个回程车：

bool ended = out.str().find('\n') != string::npos;
if(out->tellp() > 512000/*500KB*/ && ended) {

Answer 4

您可以更改flushLog 方法的实现。我假设您的实现将内部stringstream 的内容写入文件并清除它。 stringstream 的内容只能输出到最后一个换行符：

void Whatever::flushLog()
{
    std::stringstream& out = *BasicLogger::getOut();
    std::string stuff = out.str();
    size_t pos_of_newline = stuff.rfind('\n');
    if (pos_of_newline != std::string::npos)
    {
        std::string write_it_to_file = stuff.substr(0, pos_of_newline + 1);
        ... write it to file
        std::string leftover = stuff.substr(pos_of_newline + 1);
        out.str(leftover);
    }
}

代码只是一个想法；我没有检查它 - 也许有一些错误。此外：str() 调用复制了stringstream 的内容；你可能想改用它的rdbuf（我对rdbuf没有经验，所以不能推荐任何东西）。

Answer 5

根据 Useless 的建议（由名为 Useless 的用户提出的建议！！！）， 我使用Sentry(temporary) 对象解决了我的问题：

1. Logger::log["log_file"] 将返回BasicLogger 的正确实例

2. operator<< in BasicLogger 将返回 Sentry 对象的副本。

3. 后续的<<s 将由operator<< 在Sentry 对象中处理
4. Sentry 最终会在点击 ; 时超出范围，而其 destructor 将完成主要工作：

class BasicLogger {
/// operator overload. write the log items to buffer
  template<typename T>
  Sentry operator<<(const T& val) {
     Sentry t(*this,*getOut());
     t << val;//do the first << here
     return t;            
  }
//...
  class Sentry {
      std::stringstream &out;
      BasicLogger &basicLogger;
  public:
      Sentry(BasicLogger & basicLogger_, std::stringstream &out_) :
              out(out_), basicLogger(basicLogger_) {
      }
      Sentry(const Sentry& t) :
              basicLogger(t.basicLogger), out(t.out) {
      }
      template<typename T>
/// operator overload
      Sentry & operator<<(const T& val) {
          out << val;
          return *this;
      }
      ~Sentry() {
// by some googling this estimated hardcode value promises less cycles to write to a file
          if (out.tellp() > 512000/*500KB*/) {
              basicLogger.flushLog();
          }
      }
  };
//...
};

class Logger {
//...
public:
  static Logger log;
  virtual BasicLogger & operator[](const std::string &key);
  virtual ~Logger();
};