0

我正在尝试在我的日志记录类中实现我自己的流操纵器。它基本上是改变标志状态的端线操纵器。但是，当我尝试使用它时，我会得到：

ftypes.cpp:57: error: no match for ‘operator<<’ in ‘log->Log::debug() << log->Log::endl’
/usr/lib/gcc/i386-redhat-linux/4.1.2/../../../../include/c++/4.1.2/bits/ostream.tcc:67: note: candidates are: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ostream<_CharT, _Traits>& (*)(std::basic_ostream<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i386-redhat-linux/4.1.2/../../../../include/c++/4.1.2/bits/ostream.tcc:78: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ios<_CharT, _Traits>& (*)(std::basic_ios<_CharT, _Traits>&)) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/lib/gcc/i386-redhat-linux/4.1.2/../../../../include/c++/4.1.2/bits/ostream.tcc:90: note:                 std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::ios_base& (*)(std::ios_base&)) [with _CharT = char, _Traits = std::char_traits<char>]

...

代码：

class Log {
public:
  ...
  std::ostream& debug() { return log(logDEBUG); }  
  std::ostream& endl(std::ostream& out);           // manipulator
  ...
private:
  ...
  std::ofstream m_logstream;
  bool          m_newLine;
  ...
}


std::ostream& Log::endl(std::ostream& out) 
{  
  out << std::endl;
  m_newLine = true;
  return out;
}

std::ostream& Log::log(const TLogLevel level)
{
  if (level > m_logLevel) return m_nullstream;

  if (m_newLine)
  {
    m_logstream << timestamp() << "|" << logLevelString(level) << "|";
    m_newLine = false;
  }
  return m_logstream;
}

当我尝试调用它时出现错误：

log->debug() << "START - object created" << log->endl;

（log 是指向 Log 对象的指针）

有任何想法吗？我怀疑这与机械手实际上在课堂上的事实有某种联系，但这只是我的疯狂猜测......

干杯，

汤姆

编辑：由于限制格式，将其放在这里而不是评论。我尝试实现我的 streambuf，它运行良好，但有一个例外：当我尝试打开 filebuf 进行追加时，它失败了。输出效果很好，只是由于某些未知原因而没有附加。如果我尝试直接使用 ofstream 和 append 它可以工作。知道为什么吗？– 作品：

std::ofstream test; 
test.open("somefile", std::ios_base::app); 
if (!test) throw LogIoEx("Cannon open file for logging"); 
test << "test" << std::endl;

正确附加“测试”。

不起作用：

std::filebuf *fbuf = new std::filebuf(); 
if (!fbuf->open("somefile", std::ios_base::app)) throw LogIoEx("Cannon open file for logging");

抛出异常，如果我将 openmode 设置为 out 那么它可以工作..

干杯

4

3 回答 3

5

定义了一个operator<<(ostream &, ostream &(*)(ostream&))但没有一个operator<<(ostream &, ostream &(Log::*)(ostream&))。也就是说，如果操纵器是一个普通（非成员）函数，它就会工作，但是因为它依赖于 的实例Log，所以普通重载将不起作用。

要解决此问题，您可能需要log->endl成为辅助对象的实例，并在使用 推送时operator<<调用适当的代码。

像这样：

class Log {
  class ManipulationHelper {  // bad name for the class...
  public:
    typedef ostream &(Log::*ManipulatorPointer)(ostream &);

    ManipulationHelper(Log *logger, ManipulatorPointer func) :
      logger(logger),
      func(func) {
    }

    friend ostream &operator<<(ostream &stream, ManipulationHelper helper) {
        // call func on logger
        return (helper.logger)->*(helper.func)(stream);
    }

    Log *logger;
    ManipulatorPointer func;
  }

  friend class ManipulationHelper;

public:
  // ...

  ManipulationHelper endl;

private:
  // ...

  std::ostream& make_endl(std::ostream& out); // renamed
};

// ...

Log::Log(...) {
  // ...
  endl(this, make_endl) {
  // ...
}
于 2009-11-16T04:32:37.747 回答
2

这不是操纵器的工作方式——这都是关于类型的。你想要的是这样的：

class Log {
...
struct endl_tag { /* tag struct; no members */ };
static const struct endl_tag endl;
...
LogStream &debug() { /* somehow produce a LogStream type here */ }
}

LogStream &operator<<(LogStream &s, const struct endl_tag &) {
  s.m_newLine = true;
}

注意：

  1. 由于 m_newLine 是 的一部分Log，我们不能使用泛型std::ostreams。毕竟，这std::cout << Log->endl()意味着什么？所以你需要创建一个新的流类型std::ostream（我在这里省略了，但假设它是命名的LogStream）。
  2. endl它本身实际上并没有做任何事情；所有的工作都在operator<<。它的唯一目的是让正确的operator<<重载运行。

也就是说，如果可以避免的话，你不应该定义新的操纵器和流类，因为它变得复杂:) 你能做你需要的std::endl事情吗？这就是 C++ IO 库的用途。ostreamstreambuf

于 2009-11-16T04:34:03.297 回答
1

尝试这个：

#include <iostream>

class Log
{
    public:
    class LogEndl
    {
        /*
         * A class for manipulating a stream that is associated with a log.
         */
        public:
            LogEndl(Log& p)
                :parent(p)
            {}
        private:
            friend std::ostream& operator<<(std::ostream& str,Log::LogEndl const& end);
            Log&    parent;
    };
    std::ostream& debug()   {return std::cout;}
    /*
     * You are not quite using manipulators the way they are entended.
     * But I wanted to give an example that was close to your original
     *
     * So return an object that has an operator << that knows what to do.
     * To feed back info to the Log it need to keep track of who its daddy is.
     */
    LogEndl       endl()    {return LogEndl(*this);}
    private:
        friend std::ostream& operator<<(std::ostream& str,Log::LogEndl const& end);
        bool    endOfLine;

};


std::ostream& operator<<(std::ostream& str,Log::LogEndl const& end)
{
    // Stick stuff on the stream here.
    str << std::endl;

    // Make any notes you need in the log class here.
    end.parent.endOfLine    = true;

    return str;
};

int main()
{
    Log     log;

    /*
     * Please note the use of objects rather than pointers here
     * It may help
     */
    log.debug() << "Debug " << log.endl();
}
于 2009-11-16T08:55:45.233 回答